docusign_esign.apis.accounts_api

DocuSign REST API

The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501

OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git

   1# coding: utf-8
   2
   3"""
   4    DocuSign REST API
   5
   6    The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign.  # noqa: E501
   7
   8    OpenAPI spec version: v2.1
   9    Contact: devcenter@docusign.com
  10    Generated by: https://github.com/swagger-api/swagger-codegen.git
  11"""
  12
  13
  14from __future__ import absolute_import
  15
  16import sys
  17import os
  18import re
  19
  20# python 2 and python 3 compatibility library
  21from six import iteritems
  22
  23from ..client.configuration import Configuration
  24from ..client.api_client import ApiClient
  25
  26
  27class AccountsApi(object):
  28    """
  29    NOTE: This class is auto generated by the swagger code generator program.
  30    Do not edit the class manually.
  31    Ref: https://github.com/swagger-api/swagger-codegen
  32    """
  33
  34    def __init__(self, api_client=None):
  35        config = Configuration()
  36        if api_client:
  37            self.api_client = api_client
  38        else:
  39            if not config.api_client:
  40                config.api_client = ApiClient()
  41            self.api_client = config.api_client
  42
  43    def create(self, **kwargs):
  44        """
  45        Creates new accounts.
  46        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
  47        This method makes a synchronous HTTP request by default. To make an
  48        asynchronous HTTP request, please define a `callback` function
  49        to be invoked when receiving the response.
  50        >>> def callback_function(response):
  51        >>>     pprint(response)
  52        >>>
  53        >>> thread = api.create(callback=callback_function)
  54
  55        :param callback function: The callback function
  56            for asynchronous request. (optional)
  57        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
  58        :param NewAccountDefinition new_account_definition:
  59        :return: NewAccountSummary
  60                 If the method is called asynchronously,
  61                 returns the request thread.
  62        """
  63        kwargs['_return_http_data_only'] = True
  64        if kwargs.get('callback'):
  65            return self.create_with_http_info(**kwargs)
  66        else:
  67            (data) = self.create_with_http_info(**kwargs)
  68            return data
  69
  70    def create_with_http_info(self, **kwargs):
  71        """
  72        Creates new accounts.
  73        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
  74        This method makes a synchronous HTTP request by default. To make an
  75        asynchronous HTTP request, please define a `callback` function
  76        to be invoked when receiving the response.
  77        >>> def callback_function(response):
  78        >>>     pprint(response)
  79        >>>
  80        >>> thread = api.create_with_http_info(callback=callback_function)
  81
  82        :param callback function: The callback function
  83            for asynchronous request. (optional)
  84        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
  85        :param NewAccountDefinition new_account_definition:
  86        :return: NewAccountSummary
  87                 If the method is called asynchronously,
  88                 returns the request thread.
  89        """
  90
  91        all_params = ['preview_billing_plan', 'new_account_definition']
  92        all_params.append('callback')
  93        all_params.append('_return_http_data_only')
  94        all_params.append('_preload_content')
  95        all_params.append('_request_timeout')
  96
  97        params = locals()
  98        for key, val in iteritems(params['kwargs']):
  99            if key not in all_params:
 100                raise TypeError(
 101                    "Got an unexpected keyword argument '%s'"
 102                    " to method create" % key
 103                )
 104            params[key] = val
 105        del params['kwargs']
 106
 107
 108        collection_formats = {}
 109
 110        resource_path = '/v2.1/accounts'.replace('{format}', 'json')
 111        path_params = {}
 112
 113        query_params = {}
 114        if 'preview_billing_plan' in params:
 115            query_params['preview_billing_plan'] = params['preview_billing_plan']
 116
 117        header_params = {}
 118
 119        form_params = []
 120        local_var_files = {}
 121
 122        body_params = None
 123        if 'new_account_definition' in params:
 124            body_params = params['new_account_definition']
 125        # HTTP header `Accept`
 126        header_params['Accept'] = self.api_client.\
 127            select_header_accept(['application/json'])
 128
 129        # Authentication setting
 130        auth_settings = []
 131
 132        return self.api_client.call_api(resource_path, 'POST',
 133                                        path_params,
 134                                        query_params,
 135                                        header_params,
 136                                        body=body_params,
 137                                        post_params=form_params,
 138                                        files=local_var_files,
 139                                        response_type='NewAccountSummary',
 140                                        auth_settings=auth_settings,
 141                                        callback=params.get('callback'),
 142                                        _return_http_data_only=params.get('_return_http_data_only'),
 143                                        _preload_content=params.get('_preload_content', True),
 144                                        _request_timeout=params.get('_request_timeout'),
 145                                        collection_formats=collection_formats)
 146
 147    def create_account_signatures(self, account_id, **kwargs):
 148        """
 149        Adds/updates one or more account signatures. This request may include images in multi-part format.
 150        
 151        This method makes a synchronous HTTP request by default. To make an
 152        asynchronous HTTP request, please define a `callback` function
 153        to be invoked when receiving the response.
 154        >>> def callback_function(response):
 155        >>>     pprint(response)
 156        >>>
 157        >>> thread = api.create_account_signatures(account_id, callback=callback_function)
 158
 159        :param callback function: The callback function
 160            for asynchronous request. (optional)
 161        :param str account_id: The external account number (int) or account ID Guid. (required)
 162        :param str decode_only:
 163        :param AccountSignaturesInformation account_signatures_information:
 164        :return: AccountSignaturesInformation
 165                 If the method is called asynchronously,
 166                 returns the request thread.
 167        """
 168        kwargs['_return_http_data_only'] = True
 169        if kwargs.get('callback'):
 170            return self.create_account_signatures_with_http_info(account_id, **kwargs)
 171        else:
 172            (data) = self.create_account_signatures_with_http_info(account_id, **kwargs)
 173            return data
 174
 175    def create_account_signatures_with_http_info(self, account_id, **kwargs):
 176        """
 177        Adds/updates one or more account signatures. This request may include images in multi-part format.
 178        
 179        This method makes a synchronous HTTP request by default. To make an
 180        asynchronous HTTP request, please define a `callback` function
 181        to be invoked when receiving the response.
 182        >>> def callback_function(response):
 183        >>>     pprint(response)
 184        >>>
 185        >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function)
 186
 187        :param callback function: The callback function
 188            for asynchronous request. (optional)
 189        :param str account_id: The external account number (int) or account ID Guid. (required)
 190        :param str decode_only:
 191        :param AccountSignaturesInformation account_signatures_information:
 192        :return: AccountSignaturesInformation
 193                 If the method is called asynchronously,
 194                 returns the request thread.
 195        """
 196
 197        all_params = ['account_id', 'decode_only', 'account_signatures_information']
 198        all_params.append('callback')
 199        all_params.append('_return_http_data_only')
 200        all_params.append('_preload_content')
 201        all_params.append('_request_timeout')
 202
 203        params = locals()
 204        for key, val in iteritems(params['kwargs']):
 205            if key not in all_params:
 206                raise TypeError(
 207                    "Got an unexpected keyword argument '%s'"
 208                    " to method create_account_signatures" % key
 209                )
 210            params[key] = val
 211        del params['kwargs']
 212        # verify the required parameter 'account_id' is set
 213        if ('account_id' not in params) or (params['account_id'] is None):
 214            raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`")
 215
 216
 217        collection_formats = {}
 218
 219        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
 220        path_params = {}
 221        if 'account_id' in params:
 222            path_params['accountId'] = params['account_id']
 223
 224        query_params = {}
 225        if 'decode_only' in params:
 226            query_params['decode_only'] = params['decode_only']
 227
 228        header_params = {}
 229
 230        form_params = []
 231        local_var_files = {}
 232
 233        body_params = None
 234        if 'account_signatures_information' in params:
 235            body_params = params['account_signatures_information']
 236        # HTTP header `Accept`
 237        header_params['Accept'] = self.api_client.\
 238            select_header_accept(['application/json'])
 239
 240        # Authentication setting
 241        auth_settings = []
 242
 243        return self.api_client.call_api(resource_path, 'POST',
 244                                        path_params,
 245                                        query_params,
 246                                        header_params,
 247                                        body=body_params,
 248                                        post_params=form_params,
 249                                        files=local_var_files,
 250                                        response_type='AccountSignaturesInformation',
 251                                        auth_settings=auth_settings,
 252                                        callback=params.get('callback'),
 253                                        _return_http_data_only=params.get('_return_http_data_only'),
 254                                        _preload_content=params.get('_preload_content', True),
 255                                        _request_timeout=params.get('_request_timeout'),
 256                                        collection_formats=collection_formats)
 257
 258    def create_brand(self, account_id, **kwargs):
 259        """
 260        Creates one or more brand profile files for the account.
 261        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
 262        This method makes a synchronous HTTP request by default. To make an
 263        asynchronous HTTP request, please define a `callback` function
 264        to be invoked when receiving the response.
 265        >>> def callback_function(response):
 266        >>>     pprint(response)
 267        >>>
 268        >>> thread = api.create_brand(account_id, callback=callback_function)
 269
 270        :param callback function: The callback function
 271            for asynchronous request. (optional)
 272        :param str account_id: The external account number (int) or account ID GUID. (required)
 273        :param Brand brand: 
 274        :return: BrandsResponse
 275                 If the method is called asynchronously,
 276                 returns the request thread.
 277        """
 278        kwargs['_return_http_data_only'] = True
 279        if kwargs.get('callback'):
 280            return self.create_brand_with_http_info(account_id, **kwargs)
 281        else:
 282            (data) = self.create_brand_with_http_info(account_id, **kwargs)
 283            return data
 284
 285    def create_brand_with_http_info(self, account_id, **kwargs):
 286        """
 287        Creates one or more brand profile files for the account.
 288        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
 289        This method makes a synchronous HTTP request by default. To make an
 290        asynchronous HTTP request, please define a `callback` function
 291        to be invoked when receiving the response.
 292        >>> def callback_function(response):
 293        >>>     pprint(response)
 294        >>>
 295        >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function)
 296
 297        :param callback function: The callback function
 298            for asynchronous request. (optional)
 299        :param str account_id: The external account number (int) or account ID GUID. (required)
 300        :param Brand brand: 
 301        :return: BrandsResponse
 302                 If the method is called asynchronously,
 303                 returns the request thread.
 304        """
 305
 306        all_params = ['account_id', 'brand']
 307        all_params.append('callback')
 308        all_params.append('_return_http_data_only')
 309        all_params.append('_preload_content')
 310        all_params.append('_request_timeout')
 311
 312        params = locals()
 313        for key, val in iteritems(params['kwargs']):
 314            if key not in all_params:
 315                raise TypeError(
 316                    "Got an unexpected keyword argument '%s'"
 317                    " to method create_brand" % key
 318                )
 319            params[key] = val
 320        del params['kwargs']
 321        # verify the required parameter 'account_id' is set
 322        if ('account_id' not in params) or (params['account_id'] is None):
 323            raise ValueError("Missing the required parameter `account_id` when calling `create_brand`")
 324
 325
 326        collection_formats = {}
 327
 328        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
 329        path_params = {}
 330        if 'account_id' in params:
 331            path_params['accountId'] = params['account_id']
 332
 333        query_params = {}
 334
 335        header_params = {}
 336
 337        form_params = []
 338        local_var_files = {}
 339
 340        body_params = None
 341        if 'brand' in params:
 342            body_params = params['brand']
 343        # HTTP header `Accept`
 344        header_params['Accept'] = self.api_client.\
 345            select_header_accept(['application/json'])
 346
 347        # Authentication setting
 348        auth_settings = []
 349
 350        return self.api_client.call_api(resource_path, 'POST',
 351                                        path_params,
 352                                        query_params,
 353                                        header_params,
 354                                        body=body_params,
 355                                        post_params=form_params,
 356                                        files=local_var_files,
 357                                        response_type='BrandsResponse',
 358                                        auth_settings=auth_settings,
 359                                        callback=params.get('callback'),
 360                                        _return_http_data_only=params.get('_return_http_data_only'),
 361                                        _preload_content=params.get('_preload_content', True),
 362                                        _request_timeout=params.get('_request_timeout'),
 363                                        collection_formats=collection_formats)
 364
 365    def create_custom_field(self, account_id, **kwargs):
 366        """
 367        Creates an acount custom field.
 368        This method creates a custom field and makes it available for all new envelopes associated with an account.
 369        This method makes a synchronous HTTP request by default. To make an
 370        asynchronous HTTP request, please define a `callback` function
 371        to be invoked when receiving the response.
 372        >>> def callback_function(response):
 373        >>>     pprint(response)
 374        >>>
 375        >>> thread = api.create_custom_field(account_id, callback=callback_function)
 376
 377        :param callback function: The callback function
 378            for asynchronous request. (optional)
 379        :param str account_id: The external account number (int) or account ID Guid. (required)
 380        :param str apply_to_templates:
 381        :param CustomField custom_field:
 382        :return: CustomFields
 383                 If the method is called asynchronously,
 384                 returns the request thread.
 385        """
 386        kwargs['_return_http_data_only'] = True
 387        if kwargs.get('callback'):
 388            return self.create_custom_field_with_http_info(account_id, **kwargs)
 389        else:
 390            (data) = self.create_custom_field_with_http_info(account_id, **kwargs)
 391            return data
 392
 393    def create_custom_field_with_http_info(self, account_id, **kwargs):
 394        """
 395        Creates an acount custom field.
 396        This method creates a custom field and makes it available for all new envelopes associated with an account.
 397        This method makes a synchronous HTTP request by default. To make an
 398        asynchronous HTTP request, please define a `callback` function
 399        to be invoked when receiving the response.
 400        >>> def callback_function(response):
 401        >>>     pprint(response)
 402        >>>
 403        >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function)
 404
 405        :param callback function: The callback function
 406            for asynchronous request. (optional)
 407        :param str account_id: The external account number (int) or account ID Guid. (required)
 408        :param str apply_to_templates:
 409        :param CustomField custom_field:
 410        :return: CustomFields
 411                 If the method is called asynchronously,
 412                 returns the request thread.
 413        """
 414
 415        all_params = ['account_id', 'apply_to_templates', 'custom_field']
 416        all_params.append('callback')
 417        all_params.append('_return_http_data_only')
 418        all_params.append('_preload_content')
 419        all_params.append('_request_timeout')
 420
 421        params = locals()
 422        for key, val in iteritems(params['kwargs']):
 423            if key not in all_params:
 424                raise TypeError(
 425                    "Got an unexpected keyword argument '%s'"
 426                    " to method create_custom_field" % key
 427                )
 428            params[key] = val
 429        del params['kwargs']
 430        # verify the required parameter 'account_id' is set
 431        if ('account_id' not in params) or (params['account_id'] is None):
 432            raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`")
 433
 434
 435        collection_formats = {}
 436
 437        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
 438        path_params = {}
 439        if 'account_id' in params:
 440            path_params['accountId'] = params['account_id']
 441
 442        query_params = {}
 443        if 'apply_to_templates' in params:
 444            query_params['apply_to_templates'] = params['apply_to_templates']
 445
 446        header_params = {}
 447
 448        form_params = []
 449        local_var_files = {}
 450
 451        body_params = None
 452        if 'custom_field' in params:
 453            body_params = params['custom_field']
 454        # HTTP header `Accept`
 455        header_params['Accept'] = self.api_client.\
 456            select_header_accept(['application/json'])
 457
 458        # Authentication setting
 459        auth_settings = []
 460
 461        return self.api_client.call_api(resource_path, 'POST',
 462                                        path_params,
 463                                        query_params,
 464                                        header_params,
 465                                        body=body_params,
 466                                        post_params=form_params,
 467                                        files=local_var_files,
 468                                        response_type='CustomFields',
 469                                        auth_settings=auth_settings,
 470                                        callback=params.get('callback'),
 471                                        _return_http_data_only=params.get('_return_http_data_only'),
 472                                        _preload_content=params.get('_preload_content', True),
 473                                        _request_timeout=params.get('_request_timeout'),
 474                                        collection_formats=collection_formats)
 475
 476    def create_permission_profile(self, account_id, **kwargs):
 477        """
 478        Creates a new permission profile in the specified account.
 479        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
 480        This method makes a synchronous HTTP request by default. To make an
 481        asynchronous HTTP request, please define a `callback` function
 482        to be invoked when receiving the response.
 483        >>> def callback_function(response):
 484        >>>     pprint(response)
 485        >>>
 486        >>> thread = api.create_permission_profile(account_id, callback=callback_function)
 487
 488        :param callback function: The callback function
 489            for asynchronous request. (optional)
 490        :param str account_id: The external account number (int) or account ID Guid. (required)
 491        :param str include:
 492        :param PermissionProfile permission_profile:
 493        :return: PermissionProfile
 494                 If the method is called asynchronously,
 495                 returns the request thread.
 496        """
 497        kwargs['_return_http_data_only'] = True
 498        if kwargs.get('callback'):
 499            return self.create_permission_profile_with_http_info(account_id, **kwargs)
 500        else:
 501            (data) = self.create_permission_profile_with_http_info(account_id, **kwargs)
 502            return data
 503
 504    def create_permission_profile_with_http_info(self, account_id, **kwargs):
 505        """
 506        Creates a new permission profile in the specified account.
 507        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
 508        This method makes a synchronous HTTP request by default. To make an
 509        asynchronous HTTP request, please define a `callback` function
 510        to be invoked when receiving the response.
 511        >>> def callback_function(response):
 512        >>>     pprint(response)
 513        >>>
 514        >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function)
 515
 516        :param callback function: The callback function
 517            for asynchronous request. (optional)
 518        :param str account_id: The external account number (int) or account ID Guid. (required)
 519        :param str include:
 520        :param PermissionProfile permission_profile:
 521        :return: PermissionProfile
 522                 If the method is called asynchronously,
 523                 returns the request thread.
 524        """
 525
 526        all_params = ['account_id', 'include', 'permission_profile']
 527        all_params.append('callback')
 528        all_params.append('_return_http_data_only')
 529        all_params.append('_preload_content')
 530        all_params.append('_request_timeout')
 531
 532        params = locals()
 533        for key, val in iteritems(params['kwargs']):
 534            if key not in all_params:
 535                raise TypeError(
 536                    "Got an unexpected keyword argument '%s'"
 537                    " to method create_permission_profile" % key
 538                )
 539            params[key] = val
 540        del params['kwargs']
 541        # verify the required parameter 'account_id' is set
 542        if ('account_id' not in params) or (params['account_id'] is None):
 543            raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`")
 544
 545
 546        collection_formats = {}
 547
 548        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
 549        path_params = {}
 550        if 'account_id' in params:
 551            path_params['accountId'] = params['account_id']
 552
 553        query_params = {}
 554        if 'include' in params:
 555            query_params['include'] = params['include']
 556
 557        header_params = {}
 558
 559        form_params = []
 560        local_var_files = {}
 561
 562        body_params = None
 563        if 'permission_profile' in params:
 564            body_params = params['permission_profile']
 565        # HTTP header `Accept`
 566        header_params['Accept'] = self.api_client.\
 567            select_header_accept(['application/json'])
 568
 569        # Authentication setting
 570        auth_settings = []
 571
 572        return self.api_client.call_api(resource_path, 'POST',
 573                                        path_params,
 574                                        query_params,
 575                                        header_params,
 576                                        body=body_params,
 577                                        post_params=form_params,
 578                                        files=local_var_files,
 579                                        response_type='PermissionProfile',
 580                                        auth_settings=auth_settings,
 581                                        callback=params.get('callback'),
 582                                        _return_http_data_only=params.get('_return_http_data_only'),
 583                                        _preload_content=params.get('_preload_content', True),
 584                                        _request_timeout=params.get('_request_timeout'),
 585                                        collection_formats=collection_formats)
 586
 587    def delete(self, account_id, **kwargs):
 588        """
 589        Deletes the specified account.
 590        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
 591        This method makes a synchronous HTTP request by default. To make an
 592        asynchronous HTTP request, please define a `callback` function
 593        to be invoked when receiving the response.
 594        >>> def callback_function(response):
 595        >>>     pprint(response)
 596        >>>
 597        >>> thread = api.delete(account_id, callback=callback_function)
 598
 599        :param callback function: The callback function
 600            for asynchronous request. (optional)
 601        :param str account_id: The external account number (int) or account ID Guid. (required)
 602        :return: None
 603                 If the method is called asynchronously,
 604                 returns the request thread.
 605        """
 606        kwargs['_return_http_data_only'] = True
 607        if kwargs.get('callback'):
 608            return self.delete_with_http_info(account_id, **kwargs)
 609        else:
 610            (data) = self.delete_with_http_info(account_id, **kwargs)
 611            return data
 612
 613    def delete_with_http_info(self, account_id, **kwargs):
 614        """
 615        Deletes the specified account.
 616        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
 617        This method makes a synchronous HTTP request by default. To make an
 618        asynchronous HTTP request, please define a `callback` function
 619        to be invoked when receiving the response.
 620        >>> def callback_function(response):
 621        >>>     pprint(response)
 622        >>>
 623        >>> thread = api.delete_with_http_info(account_id, callback=callback_function)
 624
 625        :param callback function: The callback function
 626            for asynchronous request. (optional)
 627        :param str account_id: The external account number (int) or account ID Guid. (required)
 628        :return: None
 629                 If the method is called asynchronously,
 630                 returns the request thread.
 631        """
 632
 633        all_params = ['account_id']
 634        all_params.append('callback')
 635        all_params.append('_return_http_data_only')
 636        all_params.append('_preload_content')
 637        all_params.append('_request_timeout')
 638
 639        params = locals()
 640        for key, val in iteritems(params['kwargs']):
 641            if key not in all_params:
 642                raise TypeError(
 643                    "Got an unexpected keyword argument '%s'"
 644                    " to method delete" % key
 645                )
 646            params[key] = val
 647        del params['kwargs']
 648        # verify the required parameter 'account_id' is set
 649        if ('account_id' not in params) or (params['account_id'] is None):
 650            raise ValueError("Missing the required parameter `account_id` when calling `delete`")
 651
 652
 653        collection_formats = {}
 654
 655        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
 656        path_params = {}
 657        if 'account_id' in params:
 658            path_params['accountId'] = params['account_id']
 659
 660        query_params = {}
 661
 662        header_params = {}
 663
 664        form_params = []
 665        local_var_files = {}
 666
 667        body_params = None
 668        # HTTP header `Accept`
 669        header_params['Accept'] = self.api_client.\
 670            select_header_accept(['application/json'])
 671
 672        # Authentication setting
 673        auth_settings = []
 674
 675        return self.api_client.call_api(resource_path, 'DELETE',
 676                                        path_params,
 677                                        query_params,
 678                                        header_params,
 679                                        body=body_params,
 680                                        post_params=form_params,
 681                                        files=local_var_files,
 682                                        response_type=None,
 683                                        auth_settings=auth_settings,
 684                                        callback=params.get('callback'),
 685                                        _return_http_data_only=params.get('_return_http_data_only'),
 686                                        _preload_content=params.get('_preload_content', True),
 687                                        _request_timeout=params.get('_request_timeout'),
 688                                        collection_formats=collection_formats)
 689
 690    def delete_account_signature(self, account_id, signature_id, **kwargs):
 691        """
 692        Close the specified signature by Id.
 693        
 694        This method makes a synchronous HTTP request by default. To make an
 695        asynchronous HTTP request, please define a `callback` function
 696        to be invoked when receiving the response.
 697        >>> def callback_function(response):
 698        >>>     pprint(response)
 699        >>>
 700        >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function)
 701
 702        :param callback function: The callback function
 703            for asynchronous request. (optional)
 704        :param str account_id: The external account number (int) or account ID Guid. (required)
 705        :param str signature_id: The ID of the signature being accessed. (required)
 706        :return: None
 707                 If the method is called asynchronously,
 708                 returns the request thread.
 709        """
 710        kwargs['_return_http_data_only'] = True
 711        if kwargs.get('callback'):
 712            return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
 713        else:
 714            (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
 715            return data
 716
 717    def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
 718        """
 719        Close the specified signature by Id.
 720        
 721        This method makes a synchronous HTTP request by default. To make an
 722        asynchronous HTTP request, please define a `callback` function
 723        to be invoked when receiving the response.
 724        >>> def callback_function(response):
 725        >>>     pprint(response)
 726        >>>
 727        >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
 728
 729        :param callback function: The callback function
 730            for asynchronous request. (optional)
 731        :param str account_id: The external account number (int) or account ID Guid. (required)
 732        :param str signature_id: The ID of the signature being accessed. (required)
 733        :return: None
 734                 If the method is called asynchronously,
 735                 returns the request thread.
 736        """
 737
 738        all_params = ['account_id', 'signature_id']
 739        all_params.append('callback')
 740        all_params.append('_return_http_data_only')
 741        all_params.append('_preload_content')
 742        all_params.append('_request_timeout')
 743
 744        params = locals()
 745        for key, val in iteritems(params['kwargs']):
 746            if key not in all_params:
 747                raise TypeError(
 748                    "Got an unexpected keyword argument '%s'"
 749                    " to method delete_account_signature" % key
 750                )
 751            params[key] = val
 752        del params['kwargs']
 753        # verify the required parameter 'account_id' is set
 754        if ('account_id' not in params) or (params['account_id'] is None):
 755            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`")
 756        # verify the required parameter 'signature_id' is set
 757        if ('signature_id' not in params) or (params['signature_id'] is None):
 758            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`")
 759
 760
 761        collection_formats = {}
 762
 763        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
 764        path_params = {}
 765        if 'account_id' in params:
 766            path_params['accountId'] = params['account_id']
 767        if 'signature_id' in params:
 768            path_params['signatureId'] = params['signature_id']
 769
 770        query_params = {}
 771
 772        header_params = {}
 773
 774        form_params = []
 775        local_var_files = {}
 776
 777        body_params = None
 778        # HTTP header `Accept`
 779        header_params['Accept'] = self.api_client.\
 780            select_header_accept(['application/json'])
 781
 782        # Authentication setting
 783        auth_settings = []
 784
 785        return self.api_client.call_api(resource_path, 'DELETE',
 786                                        path_params,
 787                                        query_params,
 788                                        header_params,
 789                                        body=body_params,
 790                                        post_params=form_params,
 791                                        files=local_var_files,
 792                                        response_type=None,
 793                                        auth_settings=auth_settings,
 794                                        callback=params.get('callback'),
 795                                        _return_http_data_only=params.get('_return_http_data_only'),
 796                                        _preload_content=params.get('_preload_content', True),
 797                                        _request_timeout=params.get('_request_timeout'),
 798                                        collection_formats=collection_formats)
 799
 800    def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
 801        """
 802        Deletes a signature, initials, or stamps image.
 803        
 804        This method makes a synchronous HTTP request by default. To make an
 805        asynchronous HTTP request, please define a `callback` function
 806        to be invoked when receiving the response.
 807        >>> def callback_function(response):
 808        >>>     pprint(response)
 809        >>>
 810        >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
 811
 812        :param callback function: The callback function
 813            for asynchronous request. (optional)
 814        :param str account_id: The external account number (int) or account ID Guid. (required)
 815        :param str image_type: One of **signature_image** or **initials_image**. (required)
 816        :param str signature_id: The ID of the signature being accessed. (required)
 817        :return: AccountSignature
 818                 If the method is called asynchronously,
 819                 returns the request thread.
 820        """
 821        kwargs['_return_http_data_only'] = True
 822        if kwargs.get('callback'):
 823            return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
 824        else:
 825            (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
 826            return data
 827
 828    def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
 829        """
 830        Deletes a signature, initials, or stamps image.
 831        
 832        This method makes a synchronous HTTP request by default. To make an
 833        asynchronous HTTP request, please define a `callback` function
 834        to be invoked when receiving the response.
 835        >>> def callback_function(response):
 836        >>>     pprint(response)
 837        >>>
 838        >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
 839
 840        :param callback function: The callback function
 841            for asynchronous request. (optional)
 842        :param str account_id: The external account number (int) or account ID Guid. (required)
 843        :param str image_type: One of **signature_image** or **initials_image**. (required)
 844        :param str signature_id: The ID of the signature being accessed. (required)
 845        :return: AccountSignature
 846                 If the method is called asynchronously,
 847                 returns the request thread.
 848        """
 849
 850        all_params = ['account_id', 'image_type', 'signature_id']
 851        all_params.append('callback')
 852        all_params.append('_return_http_data_only')
 853        all_params.append('_preload_content')
 854        all_params.append('_request_timeout')
 855
 856        params = locals()
 857        for key, val in iteritems(params['kwargs']):
 858            if key not in all_params:
 859                raise TypeError(
 860                    "Got an unexpected keyword argument '%s'"
 861                    " to method delete_account_signature_image" % key
 862                )
 863            params[key] = val
 864        del params['kwargs']
 865        # verify the required parameter 'account_id' is set
 866        if ('account_id' not in params) or (params['account_id'] is None):
 867            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`")
 868        # verify the required parameter 'image_type' is set
 869        if ('image_type' not in params) or (params['image_type'] is None):
 870            raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`")
 871        # verify the required parameter 'signature_id' is set
 872        if ('signature_id' not in params) or (params['signature_id'] is None):
 873            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`")
 874
 875
 876        collection_formats = {}
 877
 878        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
 879        path_params = {}
 880        if 'account_id' in params:
 881            path_params['accountId'] = params['account_id']
 882        if 'image_type' in params:
 883            path_params['imageType'] = params['image_type']
 884        if 'signature_id' in params:
 885            path_params['signatureId'] = params['signature_id']
 886
 887        query_params = {}
 888
 889        header_params = {}
 890
 891        form_params = []
 892        local_var_files = {}
 893
 894        body_params = None
 895        # HTTP header `Accept`
 896        header_params['Accept'] = self.api_client.\
 897            select_header_accept(['application/json'])
 898
 899        # Authentication setting
 900        auth_settings = []
 901
 902        return self.api_client.call_api(resource_path, 'DELETE',
 903                                        path_params,
 904                                        query_params,
 905                                        header_params,
 906                                        body=body_params,
 907                                        post_params=form_params,
 908                                        files=local_var_files,
 909                                        response_type='AccountSignature',
 910                                        auth_settings=auth_settings,
 911                                        callback=params.get('callback'),
 912                                        _return_http_data_only=params.get('_return_http_data_only'),
 913                                        _preload_content=params.get('_preload_content', True),
 914                                        _request_timeout=params.get('_request_timeout'),
 915                                        collection_formats=collection_formats)
 916
 917    def delete_brand(self, account_id, brand_id, **kwargs):
 918        """
 919        Removes a brand.
 920        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
 921        This method makes a synchronous HTTP request by default. To make an
 922        asynchronous HTTP request, please define a `callback` function
 923        to be invoked when receiving the response.
 924        >>> def callback_function(response):
 925        >>>     pprint(response)
 926        >>>
 927        >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function)
 928
 929        :param callback function: The callback function
 930            for asynchronous request. (optional)
 931        :param str account_id: The external account number (int) or account ID Guid. (required)
 932        :param str brand_id: The unique identifier of a brand. (required)
 933        :return: None
 934                 If the method is called asynchronously,
 935                 returns the request thread.
 936        """
 937        kwargs['_return_http_data_only'] = True
 938        if kwargs.get('callback'):
 939            return self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
 940        else:
 941            (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
 942            return data
 943
 944    def delete_brand_with_http_info(self, account_id, brand_id, **kwargs):
 945        """
 946        Removes a brand.
 947        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
 948        This method makes a synchronous HTTP request by default. To make an
 949        asynchronous HTTP request, please define a `callback` function
 950        to be invoked when receiving the response.
 951        >>> def callback_function(response):
 952        >>>     pprint(response)
 953        >>>
 954        >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
 955
 956        :param callback function: The callback function
 957            for asynchronous request. (optional)
 958        :param str account_id: The external account number (int) or account ID Guid. (required)
 959        :param str brand_id: The unique identifier of a brand. (required)
 960        :return: None
 961                 If the method is called asynchronously,
 962                 returns the request thread.
 963        """
 964
 965        all_params = ['account_id', 'brand_id']
 966        all_params.append('callback')
 967        all_params.append('_return_http_data_only')
 968        all_params.append('_preload_content')
 969        all_params.append('_request_timeout')
 970
 971        params = locals()
 972        for key, val in iteritems(params['kwargs']):
 973            if key not in all_params:
 974                raise TypeError(
 975                    "Got an unexpected keyword argument '%s'"
 976                    " to method delete_brand" % key
 977                )
 978            params[key] = val
 979        del params['kwargs']
 980        # verify the required parameter 'account_id' is set
 981        if ('account_id' not in params) or (params['account_id'] is None):
 982            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`")
 983        # verify the required parameter 'brand_id' is set
 984        if ('brand_id' not in params) or (params['brand_id'] is None):
 985            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`")
 986
 987
 988        collection_formats = {}
 989
 990        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
 991        path_params = {}
 992        if 'account_id' in params:
 993            path_params['accountId'] = params['account_id']
 994        if 'brand_id' in params:
 995            path_params['brandId'] = params['brand_id']
 996
 997        query_params = {}
 998
 999        header_params = {}
1000
1001        form_params = []
1002        local_var_files = {}
1003
1004        body_params = None
1005        # HTTP header `Accept`
1006        header_params['Accept'] = self.api_client.\
1007            select_header_accept(['application/json'])
1008
1009        # Authentication setting
1010        auth_settings = []
1011
1012        return self.api_client.call_api(resource_path, 'DELETE',
1013                                        path_params,
1014                                        query_params,
1015                                        header_params,
1016                                        body=body_params,
1017                                        post_params=form_params,
1018                                        files=local_var_files,
1019                                        response_type=None,
1020                                        auth_settings=auth_settings,
1021                                        callback=params.get('callback'),
1022                                        _return_http_data_only=params.get('_return_http_data_only'),
1023                                        _preload_content=params.get('_preload_content', True),
1024                                        _request_timeout=params.get('_request_timeout'),
1025                                        collection_formats=collection_formats)
1026
1027    def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
1028        """
1029        Delete one branding logo.
1030        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1031        This method makes a synchronous HTTP request by default. To make an
1032        asynchronous HTTP request, please define a `callback` function
1033        to be invoked when receiving the response.
1034        >>> def callback_function(response):
1035        >>>     pprint(response)
1036        >>>
1037        >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
1038
1039        :param callback function: The callback function
1040            for asynchronous request. (optional)
1041        :param str account_id: The external account number (int) or account ID Guid. (required)
1042        :param str brand_id: The unique identifier of a brand. (required)
1043        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1044        :return: None
1045                 If the method is called asynchronously,
1046                 returns the request thread.
1047        """
1048        kwargs['_return_http_data_only'] = True
1049        if kwargs.get('callback'):
1050            return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1051        else:
1052            (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1053            return data
1054
1055    def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
1056        """
1057        Delete one branding logo.
1058        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1059        This method makes a synchronous HTTP request by default. To make an
1060        asynchronous HTTP request, please define a `callback` function
1061        to be invoked when receiving the response.
1062        >>> def callback_function(response):
1063        >>>     pprint(response)
1064        >>>
1065        >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
1066
1067        :param callback function: The callback function
1068            for asynchronous request. (optional)
1069        :param str account_id: The external account number (int) or account ID Guid. (required)
1070        :param str brand_id: The unique identifier of a brand. (required)
1071        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1072        :return: None
1073                 If the method is called asynchronously,
1074                 returns the request thread.
1075        """
1076
1077        all_params = ['account_id', 'brand_id', 'logo_type']
1078        all_params.append('callback')
1079        all_params.append('_return_http_data_only')
1080        all_params.append('_preload_content')
1081        all_params.append('_request_timeout')
1082
1083        params = locals()
1084        for key, val in iteritems(params['kwargs']):
1085            if key not in all_params:
1086                raise TypeError(
1087                    "Got an unexpected keyword argument '%s'"
1088                    " to method delete_brand_logo_by_type" % key
1089                )
1090            params[key] = val
1091        del params['kwargs']
1092        # verify the required parameter 'account_id' is set
1093        if ('account_id' not in params) or (params['account_id'] is None):
1094            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`")
1095        # verify the required parameter 'brand_id' is set
1096        if ('brand_id' not in params) or (params['brand_id'] is None):
1097            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`")
1098        # verify the required parameter 'logo_type' is set
1099        if ('logo_type' not in params) or (params['logo_type'] is None):
1100            raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`")
1101
1102
1103        collection_formats = {}
1104
1105        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
1106        path_params = {}
1107        if 'account_id' in params:
1108            path_params['accountId'] = params['account_id']
1109        if 'brand_id' in params:
1110            path_params['brandId'] = params['brand_id']
1111        if 'logo_type' in params:
1112            path_params['logoType'] = params['logo_type']
1113
1114        query_params = {}
1115
1116        header_params = {}
1117
1118        form_params = []
1119        local_var_files = {}
1120
1121        body_params = None
1122        # HTTP header `Accept`
1123        header_params['Accept'] = self.api_client.\
1124            select_header_accept(['application/json'])
1125
1126        # Authentication setting
1127        auth_settings = []
1128
1129        return self.api_client.call_api(resource_path, 'DELETE',
1130                                        path_params,
1131                                        query_params,
1132                                        header_params,
1133                                        body=body_params,
1134                                        post_params=form_params,
1135                                        files=local_var_files,
1136                                        response_type=None,
1137                                        auth_settings=auth_settings,
1138                                        callback=params.get('callback'),
1139                                        _return_http_data_only=params.get('_return_http_data_only'),
1140                                        _preload_content=params.get('_preload_content', True),
1141                                        _request_timeout=params.get('_request_timeout'),
1142                                        collection_formats=collection_formats)
1143
1144    def delete_brands(self, account_id, **kwargs):
1145        """
1146        Deletes one or more brand profiles.
1147        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1148        This method makes a synchronous HTTP request by default. To make an
1149        asynchronous HTTP request, please define a `callback` function
1150        to be invoked when receiving the response.
1151        >>> def callback_function(response):
1152        >>>     pprint(response)
1153        >>>
1154        >>> thread = api.delete_brands(account_id, callback=callback_function)
1155
1156        :param callback function: The callback function
1157            for asynchronous request. (optional)
1158        :param str account_id: The external account number (int) or account ID Guid. (required)
1159        :param BrandsRequest brands_request:
1160        :return: BrandsResponse
1161                 If the method is called asynchronously,
1162                 returns the request thread.
1163        """
1164        kwargs['_return_http_data_only'] = True
1165        if kwargs.get('callback'):
1166            return self.delete_brands_with_http_info(account_id, **kwargs)
1167        else:
1168            (data) = self.delete_brands_with_http_info(account_id, **kwargs)
1169            return data
1170
1171    def delete_brands_with_http_info(self, account_id, **kwargs):
1172        """
1173        Deletes one or more brand profiles.
1174        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1175        This method makes a synchronous HTTP request by default. To make an
1176        asynchronous HTTP request, please define a `callback` function
1177        to be invoked when receiving the response.
1178        >>> def callback_function(response):
1179        >>>     pprint(response)
1180        >>>
1181        >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function)
1182
1183        :param callback function: The callback function
1184            for asynchronous request. (optional)
1185        :param str account_id: The external account number (int) or account ID Guid. (required)
1186        :param BrandsRequest brands_request:
1187        :return: BrandsResponse
1188                 If the method is called asynchronously,
1189                 returns the request thread.
1190        """
1191
1192        all_params = ['account_id', 'brands_request']
1193        all_params.append('callback')
1194        all_params.append('_return_http_data_only')
1195        all_params.append('_preload_content')
1196        all_params.append('_request_timeout')
1197
1198        params = locals()
1199        for key, val in iteritems(params['kwargs']):
1200            if key not in all_params:
1201                raise TypeError(
1202                    "Got an unexpected keyword argument '%s'"
1203                    " to method delete_brands" % key
1204                )
1205            params[key] = val
1206        del params['kwargs']
1207        # verify the required parameter 'account_id' is set
1208        if ('account_id' not in params) or (params['account_id'] is None):
1209            raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`")
1210
1211
1212        collection_formats = {}
1213
1214        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
1215        path_params = {}
1216        if 'account_id' in params:
1217            path_params['accountId'] = params['account_id']
1218
1219        query_params = {}
1220
1221        header_params = {}
1222
1223        form_params = []
1224        local_var_files = {}
1225
1226        body_params = None
1227        if 'brands_request' in params:
1228            body_params = params['brands_request']
1229        # HTTP header `Accept`
1230        header_params['Accept'] = self.api_client.\
1231            select_header_accept(['application/json'])
1232
1233        # Authentication setting
1234        auth_settings = []
1235
1236        return self.api_client.call_api(resource_path, 'DELETE',
1237                                        path_params,
1238                                        query_params,
1239                                        header_params,
1240                                        body=body_params,
1241                                        post_params=form_params,
1242                                        files=local_var_files,
1243                                        response_type='BrandsResponse',
1244                                        auth_settings=auth_settings,
1245                                        callback=params.get('callback'),
1246                                        _return_http_data_only=params.get('_return_http_data_only'),
1247                                        _preload_content=params.get('_preload_content', True),
1248                                        _request_timeout=params.get('_request_timeout'),
1249                                        collection_formats=collection_formats)
1250
1251    def delete_captive_recipient(self, account_id, recipient_part, **kwargs):
1252        """
1253        Deletes the signature for one or more captive recipient records.
1254        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1255        This method makes a synchronous HTTP request by default. To make an
1256        asynchronous HTTP request, please define a `callback` function
1257        to be invoked when receiving the response.
1258        >>> def callback_function(response):
1259        >>>     pprint(response)
1260        >>>
1261        >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function)
1262
1263        :param callback function: The callback function
1264            for asynchronous request. (optional)
1265        :param str account_id: The external account number (int) or account ID Guid. (required)
1266        :param str recipient_part: (required)
1267        :param CaptiveRecipientInformation captive_recipient_information:
1268        :return: CaptiveRecipientInformation
1269                 If the method is called asynchronously,
1270                 returns the request thread.
1271        """
1272        kwargs['_return_http_data_only'] = True
1273        if kwargs.get('callback'):
1274            return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1275        else:
1276            (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1277            return data
1278
1279    def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs):
1280        """
1281        Deletes the signature for one or more captive recipient records.
1282        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1283        This method makes a synchronous HTTP request by default. To make an
1284        asynchronous HTTP request, please define a `callback` function
1285        to be invoked when receiving the response.
1286        >>> def callback_function(response):
1287        >>>     pprint(response)
1288        >>>
1289        >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
1290
1291        :param callback function: The callback function
1292            for asynchronous request. (optional)
1293        :param str account_id: The external account number (int) or account ID Guid. (required)
1294        :param str recipient_part: (required)
1295        :param CaptiveRecipientInformation captive_recipient_information:
1296        :return: CaptiveRecipientInformation
1297                 If the method is called asynchronously,
1298                 returns the request thread.
1299        """
1300
1301        all_params = ['account_id', 'recipient_part', 'captive_recipient_information']
1302        all_params.append('callback')
1303        all_params.append('_return_http_data_only')
1304        all_params.append('_preload_content')
1305        all_params.append('_request_timeout')
1306
1307        params = locals()
1308        for key, val in iteritems(params['kwargs']):
1309            if key not in all_params:
1310                raise TypeError(
1311                    "Got an unexpected keyword argument '%s'"
1312                    " to method delete_captive_recipient" % key
1313                )
1314            params[key] = val
1315        del params['kwargs']
1316        # verify the required parameter 'account_id' is set
1317        if ('account_id' not in params) or (params['account_id'] is None):
1318            raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`")
1319        # verify the required parameter 'recipient_part' is set
1320        if ('recipient_part' not in params) or (params['recipient_part'] is None):
1321            raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`")
1322
1323
1324        collection_formats = {}
1325
1326        resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json')
1327        path_params = {}
1328        if 'account_id' in params:
1329            path_params['accountId'] = params['account_id']
1330        if 'recipient_part' in params:
1331            path_params['recipientPart'] = params['recipient_part']
1332
1333        query_params = {}
1334
1335        header_params = {}
1336
1337        form_params = []
1338        local_var_files = {}
1339
1340        body_params = None
1341        if 'captive_recipient_information' in params:
1342            body_params = params['captive_recipient_information']
1343        # HTTP header `Accept`
1344        header_params['Accept'] = self.api_client.\
1345            select_header_accept(['application/json'])
1346
1347        # Authentication setting
1348        auth_settings = []
1349
1350        return self.api_client.call_api(resource_path, 'DELETE',
1351                                        path_params,
1352                                        query_params,
1353                                        header_params,
1354                                        body=body_params,
1355                                        post_params=form_params,
1356                                        files=local_var_files,
1357                                        response_type='CaptiveRecipientInformation',
1358                                        auth_settings=auth_settings,
1359                                        callback=params.get('callback'),
1360                                        _return_http_data_only=params.get('_return_http_data_only'),
1361                                        _preload_content=params.get('_preload_content', True),
1362                                        _request_timeout=params.get('_request_timeout'),
1363                                        collection_formats=collection_formats)
1364
1365    def delete_custom_field(self, account_id, custom_field_id, **kwargs):
1366        """
1367        Delete an existing account custom field.
1368        This method deletes an existing account custom field.
1369        This method makes a synchronous HTTP request by default. To make an
1370        asynchronous HTTP request, please define a `callback` function
1371        to be invoked when receiving the response.
1372        >>> def callback_function(response):
1373        >>>     pprint(response)
1374        >>>
1375        >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function)
1376
1377        :param callback function: The callback function
1378            for asynchronous request. (optional)
1379        :param str account_id: The external account number (int) or account ID Guid. (required)
1380        :param str custom_field_id: (required)
1381        :param str apply_to_templates:
1382        :return: None
1383                 If the method is called asynchronously,
1384                 returns the request thread.
1385        """
1386        kwargs['_return_http_data_only'] = True
1387        if kwargs.get('callback'):
1388            return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1389        else:
1390            (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1391            return data
1392
1393    def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
1394        """
1395        Delete an existing account custom field.
1396        This method deletes an existing account custom field.
1397        This method makes a synchronous HTTP request by default. To make an
1398        asynchronous HTTP request, please define a `callback` function
1399        to be invoked when receiving the response.
1400        >>> def callback_function(response):
1401        >>>     pprint(response)
1402        >>>
1403        >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
1404
1405        :param callback function: The callback function
1406            for asynchronous request. (optional)
1407        :param str account_id: The external account number (int) or account ID Guid. (required)
1408        :param str custom_field_id: (required)
1409        :param str apply_to_templates:
1410        :return: None
1411                 If the method is called asynchronously,
1412                 returns the request thread.
1413        """
1414
1415        all_params = ['account_id', 'custom_field_id', 'apply_to_templates']
1416        all_params.append('callback')
1417        all_params.append('_return_http_data_only')
1418        all_params.append('_preload_content')
1419        all_params.append('_request_timeout')
1420
1421        params = locals()
1422        for key, val in iteritems(params['kwargs']):
1423            if key not in all_params:
1424                raise TypeError(
1425                    "Got an unexpected keyword argument '%s'"
1426                    " to method delete_custom_field" % key
1427                )
1428            params[key] = val
1429        del params['kwargs']
1430        # verify the required parameter 'account_id' is set
1431        if ('account_id' not in params) or (params['account_id'] is None):
1432            raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`")
1433        # verify the required parameter 'custom_field_id' is set
1434        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
1435            raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`")
1436
1437
1438        collection_formats = {}
1439
1440        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
1441        path_params = {}
1442        if 'account_id' in params:
1443            path_params['accountId'] = params['account_id']
1444        if 'custom_field_id' in params:
1445            path_params['customFieldId'] = params['custom_field_id']
1446
1447        query_params = {}
1448        if 'apply_to_templates' in params:
1449            query_params['apply_to_templates'] = params['apply_to_templates']
1450
1451        header_params = {}
1452
1453        form_params = []
1454        local_var_files = {}
1455
1456        body_params = None
1457        # HTTP header `Accept`
1458        header_params['Accept'] = self.api_client.\
1459            select_header_accept(['application/json'])
1460
1461        # Authentication setting
1462        auth_settings = []
1463
1464        return self.api_client.call_api(resource_path, 'DELETE',
1465                                        path_params,
1466                                        query_params,
1467                                        header_params,
1468                                        body=body_params,
1469                                        post_params=form_params,
1470                                        files=local_var_files,
1471                                        response_type=None,
1472                                        auth_settings=auth_settings,
1473                                        callback=params.get('callback'),
1474                                        _return_http_data_only=params.get('_return_http_data_only'),
1475                                        _preload_content=params.get('_preload_content', True),
1476                                        _request_timeout=params.get('_request_timeout'),
1477                                        collection_formats=collection_formats)
1478
1479    def delete_e_note_configuration(self, account_id, **kwargs):
1480        """
1481        Deletes configuration information for the eNote eOriginal integration.
1482        
1483        This method makes a synchronous HTTP request by default. To make an
1484        asynchronous HTTP request, please define a `callback` function
1485        to be invoked when receiving the response.
1486        >>> def callback_function(response):
1487        >>>     pprint(response)
1488        >>>
1489        >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function)
1490
1491        :param callback function: The callback function
1492            for asynchronous request. (optional)
1493        :param str account_id: The external account number (int) or account ID Guid. (required)
1494        :return: None
1495                 If the method is called asynchronously,
1496                 returns the request thread.
1497        """
1498        kwargs['_return_http_data_only'] = True
1499        if kwargs.get('callback'):
1500            return self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1501        else:
1502            (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1503            return data
1504
1505    def delete_e_note_configuration_with_http_info(self, account_id, **kwargs):
1506        """
1507        Deletes configuration information for the eNote eOriginal integration.
1508        
1509        This method makes a synchronous HTTP request by default. To make an
1510        asynchronous HTTP request, please define a `callback` function
1511        to be invoked when receiving the response.
1512        >>> def callback_function(response):
1513        >>>     pprint(response)
1514        >>>
1515        >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function)
1516
1517        :param callback function: The callback function
1518            for asynchronous request. (optional)
1519        :param str account_id: The external account number (int) or account ID Guid. (required)
1520        :return: None
1521                 If the method is called asynchronously,
1522                 returns the request thread.
1523        """
1524
1525        all_params = ['account_id']
1526        all_params.append('callback')
1527        all_params.append('_return_http_data_only')
1528        all_params.append('_preload_content')
1529        all_params.append('_request_timeout')
1530
1531        params = locals()
1532        for key, val in iteritems(params['kwargs']):
1533            if key not in all_params:
1534                raise TypeError(
1535                    "Got an unexpected keyword argument '%s'"
1536                    " to method delete_e_note_configuration" % key
1537                )
1538            params[key] = val
1539        del params['kwargs']
1540        # verify the required parameter 'account_id' is set
1541        if ('account_id' not in params) or (params['account_id'] is None):
1542            raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`")
1543
1544
1545        collection_formats = {}
1546
1547        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
1548        path_params = {}
1549        if 'account_id' in params:
1550            path_params['accountId'] = params['account_id']
1551
1552        query_params = {}
1553
1554        header_params = {}
1555
1556        form_params = []
1557        local_var_files = {}
1558
1559        body_params = None
1560        # HTTP header `Accept`
1561        header_params['Accept'] = self.api_client.\
1562            select_header_accept(['application/json'])
1563
1564        # Authentication setting
1565        auth_settings = []
1566
1567        return self.api_client.call_api(resource_path, 'DELETE',
1568                                        path_params,
1569                                        query_params,
1570                                        header_params,
1571                                        body=body_params,
1572                                        post_params=form_params,
1573                                        files=local_var_files,
1574                                        response_type=None,
1575                                        auth_settings=auth_settings,
1576                                        callback=params.get('callback'),
1577                                        _return_http_data_only=params.get('_return_http_data_only'),
1578                                        _preload_content=params.get('_preload_content', True),
1579                                        _request_timeout=params.get('_request_timeout'),
1580                                        collection_formats=collection_formats)
1581
1582    def delete_permission_profile(self, account_id, permission_profile_id, **kwargs):
1583        """
1584        Deletes a permissions profile within the specified account.
1585        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1586        This method makes a synchronous HTTP request by default. To make an
1587        asynchronous HTTP request, please define a `callback` function
1588        to be invoked when receiving the response.
1589        >>> def callback_function(response):
1590        >>>     pprint(response)
1591        >>>
1592        >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function)
1593
1594        :param callback function: The callback function
1595            for asynchronous request. (optional)
1596        :param str account_id: The external account number (int) or account ID Guid. (required)
1597        :param str permission_profile_id: (required)
1598        :param str move_users_to:
1599        :return: None
1600                 If the method is called asynchronously,
1601                 returns the request thread.
1602        """
1603        kwargs['_return_http_data_only'] = True
1604        if kwargs.get('callback'):
1605            return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1606        else:
1607            (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1608            return data
1609
1610    def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
1611        """
1612        Deletes a permissions profile within the specified account.
1613        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1614        This method makes a synchronous HTTP request by default. To make an
1615        asynchronous HTTP request, please define a `callback` function
1616        to be invoked when receiving the response.
1617        >>> def callback_function(response):
1618        >>>     pprint(response)
1619        >>>
1620        >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
1621
1622        :param callback function: The callback function
1623            for asynchronous request. (optional)
1624        :param str account_id: The external account number (int) or account ID Guid. (required)
1625        :param str permission_profile_id: (required)
1626        :param str move_users_to:
1627        :return: None
1628                 If the method is called asynchronously,
1629                 returns the request thread.
1630        """
1631
1632        all_params = ['account_id', 'permission_profile_id', 'move_users_to']
1633        all_params.append('callback')
1634        all_params.append('_return_http_data_only')
1635        all_params.append('_preload_content')
1636        all_params.append('_request_timeout')
1637
1638        params = locals()
1639        for key, val in iteritems(params['kwargs']):
1640            if key not in all_params:
1641                raise TypeError(
1642                    "Got an unexpected keyword argument '%s'"
1643                    " to method delete_permission_profile" % key
1644                )
1645            params[key] = val
1646        del params['kwargs']
1647        # verify the required parameter 'account_id' is set
1648        if ('account_id' not in params) or (params['account_id'] is None):
1649            raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`")
1650        # verify the required parameter 'permission_profile_id' is set
1651        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
1652            raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`")
1653
1654
1655        collection_formats = {}
1656
1657        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
1658        path_params = {}
1659        if 'account_id' in params:
1660            path_params['accountId'] = params['account_id']
1661        if 'permission_profile_id' in params:
1662            path_params['permissionProfileId'] = params['permission_profile_id']
1663
1664        query_params = {}
1665        if 'move_users_to' in params:
1666            query_params['move_users_to'] = params['move_users_to']
1667
1668        header_params = {}
1669
1670        form_params = []
1671        local_var_files = {}
1672
1673        body_params = None
1674        # HTTP header `Accept`
1675        header_params['Accept'] = self.api_client.\
1676            select_header_accept(['application/json'])
1677
1678        # Authentication setting
1679        auth_settings = []
1680
1681        return self.api_client.call_api(resource_path, 'DELETE',
1682                                        path_params,
1683                                        query_params,
1684                                        header_params,
1685                                        body=body_params,
1686                                        post_params=form_params,
1687                                        files=local_var_files,
1688                                        response_type=None,
1689                                        auth_settings=auth_settings,
1690                                        callback=params.get('callback'),
1691                                        _return_http_data_only=params.get('_return_http_data_only'),
1692                                        _preload_content=params.get('_preload_content', True),
1693                                        _request_timeout=params.get('_request_timeout'),
1694                                        collection_formats=collection_formats)
1695
1696    def get_account_identity_verification(self, account_id, **kwargs):
1697        """
1698        Get the list of identity verification options for an account
1699        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1700        This method makes a synchronous HTTP request by default. To make an
1701        asynchronous HTTP request, please define a `callback` function
1702        to be invoked when receiving the response.
1703        >>> def callback_function(response):
1704        >>>     pprint(response)
1705        >>>
1706        >>> thread = api.get_account_identity_verification(account_id, callback=callback_function)
1707
1708        :param callback function: The callback function
1709            for asynchronous request. (optional)
1710        :param str account_id: The external account number (int) or account ID Guid. (required)
1711        :return: AccountIdentityVerificationResponse
1712                 If the method is called asynchronously,
1713                 returns the request thread.
1714        """
1715        kwargs['_return_http_data_only'] = True
1716        if kwargs.get('callback'):
1717            return self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1718        else:
1719            (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1720            return data
1721
1722    def get_account_identity_verification_with_http_info(self, account_id, **kwargs):
1723        """
1724        Get the list of identity verification options for an account
1725        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1726        This method makes a synchronous HTTP request by default. To make an
1727        asynchronous HTTP request, please define a `callback` function
1728        to be invoked when receiving the response.
1729        >>> def callback_function(response):
1730        >>>     pprint(response)
1731        >>>
1732        >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function)
1733
1734        :param callback function: The callback function
1735            for asynchronous request. (optional)
1736        :param str account_id: The external account number (int) or account ID Guid. (required)
1737        :return: AccountIdentityVerificationResponse
1738                 If the method is called asynchronously,
1739                 returns the request thread.
1740        """
1741
1742        all_params = ['account_id']
1743        all_params.append('callback')
1744        all_params.append('_return_http_data_only')
1745        all_params.append('_preload_content')
1746        all_params.append('_request_timeout')
1747
1748        params = locals()
1749        for key, val in iteritems(params['kwargs']):
1750            if key not in all_params:
1751                raise TypeError(
1752                    "Got an unexpected keyword argument '%s'"
1753                    " to method get_account_identity_verification" % key
1754                )
1755            params[key] = val
1756        del params['kwargs']
1757        # verify the required parameter 'account_id' is set
1758        if ('account_id' not in params) or (params['account_id'] is None):
1759            raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`")
1760
1761
1762        collection_formats = {}
1763
1764        resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json')
1765        path_params = {}
1766        if 'account_id' in params:
1767            path_params['accountId'] = params['account_id']
1768
1769        query_params = {}
1770
1771        header_params = {}
1772
1773        form_params = []
1774        local_var_files = {}
1775
1776        body_params = None
1777        # HTTP header `Accept`
1778        header_params['Accept'] = self.api_client.\
1779            select_header_accept(['application/json'])
1780
1781        # Authentication setting
1782        auth_settings = []
1783
1784        return self.api_client.call_api(resource_path, 'GET',
1785                                        path_params,
1786                                        query_params,
1787                                        header_params,
1788                                        body=body_params,
1789                                        post_params=form_params,
1790                                        files=local_var_files,
1791                                        response_type='AccountIdentityVerificationResponse',
1792                                        auth_settings=auth_settings,
1793                                        callback=params.get('callback'),
1794                                        _return_http_data_only=params.get('_return_http_data_only'),
1795                                        _preload_content=params.get('_preload_content', True),
1796                                        _request_timeout=params.get('_request_timeout'),
1797                                        collection_formats=collection_formats)
1798
1799    def get_account_information(self, account_id, **kwargs):
1800        """
1801        Retrieves the account information for the specified account.
1802        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1803        This method makes a synchronous HTTP request by default. To make an
1804        asynchronous HTTP request, please define a `callback` function
1805        to be invoked when receiving the response.
1806        >>> def callback_function(response):
1807        >>>     pprint(response)
1808        >>>
1809        >>> thread = api.get_account_information(account_id, callback=callback_function)
1810
1811        :param callback function: The callback function
1812            for asynchronous request. (optional)
1813        :param str account_id: The external account number (int) or account ID Guid. (required)
1814        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1815        :return: AccountInformation
1816                 If the method is called asynchronously,
1817                 returns the request thread.
1818        """
1819        kwargs['_return_http_data_only'] = True
1820        if kwargs.get('callback'):
1821            return self.get_account_information_with_http_info(account_id, **kwargs)
1822        else:
1823            (data) = self.get_account_information_with_http_info(account_id, **kwargs)
1824            return data
1825
1826    def get_account_information_with_http_info(self, account_id, **kwargs):
1827        """
1828        Retrieves the account information for the specified account.
1829        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1830        This method makes a synchronous HTTP request by default. To make an
1831        asynchronous HTTP request, please define a `callback` function
1832        to be invoked when receiving the response.
1833        >>> def callback_function(response):
1834        >>>     pprint(response)
1835        >>>
1836        >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
1837
1838        :param callback function: The callback function
1839            for asynchronous request. (optional)
1840        :param str account_id: The external account number (int) or account ID Guid. (required)
1841        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1842        :return: AccountInformation
1843                 If the method is called asynchronously,
1844                 returns the request thread.
1845        """
1846
1847        all_params = ['account_id', 'include_account_settings']
1848        all_params.append('callback')
1849        all_params.append('_return_http_data_only')
1850        all_params.append('_preload_content')
1851        all_params.append('_request_timeout')
1852
1853        params = locals()
1854        for key, val in iteritems(params['kwargs']):
1855            if key not in all_params:
1856                raise TypeError(
1857                    "Got an unexpected keyword argument '%s'"
1858                    " to method get_account_information" % key
1859                )
1860            params[key] = val
1861        del params['kwargs']
1862        # verify the required parameter 'account_id' is set
1863        if ('account_id' not in params) or (params['account_id'] is None):
1864            raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`")
1865
1866
1867        collection_formats = {}
1868
1869        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
1870        path_params = {}
1871        if 'account_id' in params:
1872            path_params['accountId'] = params['account_id']
1873
1874        query_params = {}
1875        if 'include_account_settings' in params:
1876            query_params['include_account_settings'] = params['include_account_settings']
1877
1878        header_params = {}
1879
1880        form_params = []
1881        local_var_files = {}
1882
1883        body_params = None
1884        # HTTP header `Accept`
1885        header_params['Accept'] = self.api_client.\
1886            select_header_accept(['application/json'])
1887
1888        # Authentication setting
1889        auth_settings = []
1890
1891        return self.api_client.call_api(resource_path, 'GET',
1892                                        path_params,
1893                                        query_params,
1894                                        header_params,
1895                                        body=body_params,
1896                                        post_params=form_params,
1897                                        files=local_var_files,
1898                                        response_type='AccountInformation',
1899                                        auth_settings=auth_settings,
1900                                        callback=params.get('callback'),
1901                                        _return_http_data_only=params.get('_return_http_data_only'),
1902                                        _preload_content=params.get('_preload_content', True),
1903                                        _request_timeout=params.get('_request_timeout'),
1904                                        collection_formats=collection_formats)
1905
1906    def get_account_signature(self, account_id, signature_id, **kwargs):
1907        """
1908        Returns information about a single signature by specifed signatureId.
1909        
1910        This method makes a synchronous HTTP request by default. To make an
1911        asynchronous HTTP request, please define a `callback` function
1912        to be invoked when receiving the response.
1913        >>> def callback_function(response):
1914        >>>     pprint(response)
1915        >>>
1916        >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function)
1917
1918        :param callback function: The callback function
1919            for asynchronous request. (optional)
1920        :param str account_id: The external account number (int) or account ID Guid. (required)
1921        :param str signature_id: The ID of the signature being accessed. (required)
1922        :return: AccountSignature
1923                 If the method is called asynchronously,
1924                 returns the request thread.
1925        """
1926        kwargs['_return_http_data_only'] = True
1927        if kwargs.get('callback'):
1928            return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1929        else:
1930            (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1931            return data
1932
1933    def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
1934        """
1935        Returns information about a single signature by specifed signatureId.
1936        
1937        This method makes a synchronous HTTP request by default. To make an
1938        asynchronous HTTP request, please define a `callback` function
1939        to be invoked when receiving the response.
1940        >>> def callback_function(response):
1941        >>>     pprint(response)
1942        >>>
1943        >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
1944
1945        :param callback function: The callback function
1946            for asynchronous request. (optional)
1947        :param str account_id: The external account number (int) or account ID Guid. (required)
1948        :param str signature_id: The ID of the signature being accessed. (required)
1949        :return: AccountSignature
1950                 If the method is called asynchronously,
1951                 returns the request thread.
1952        """
1953
1954        all_params = ['account_id', 'signature_id']
1955        all_params.append('callback')
1956        all_params.append('_return_http_data_only')
1957        all_params.append('_preload_content')
1958        all_params.append('_request_timeout')
1959
1960        params = locals()
1961        for key, val in iteritems(params['kwargs']):
1962            if key not in all_params:
1963                raise TypeError(
1964                    "Got an unexpected keyword argument '%s'"
1965                    " to method get_account_signature" % key
1966                )
1967            params[key] = val
1968        del params['kwargs']
1969        # verify the required parameter 'account_id' is set
1970        if ('account_id' not in params) or (params['account_id'] is None):
1971            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`")
1972        # verify the required parameter 'signature_id' is set
1973        if ('signature_id' not in params) or (params['signature_id'] is None):
1974            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`")
1975
1976
1977        collection_formats = {}
1978
1979        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
1980        path_params = {}
1981        if 'account_id' in params:
1982            path_params['accountId'] = params['account_id']
1983        if 'signature_id' in params:
1984            path_params['signatureId'] = params['signature_id']
1985
1986        query_params = {}
1987
1988        header_params = {}
1989
1990        form_params = []
1991        local_var_files = {}
1992
1993        body_params = None
1994        # HTTP header `Accept`
1995        header_params['Accept'] = self.api_client.\
1996            select_header_accept(['application/json'])
1997
1998        # Authentication setting
1999        auth_settings = []
2000
2001        return self.api_client.call_api(resource_path, 'GET',
2002                                        path_params,
2003                                        query_params,
2004                                        header_params,
2005                                        body=body_params,
2006                                        post_params=form_params,
2007                                        files=local_var_files,
2008                                        response_type='AccountSignature',
2009                                        auth_settings=auth_settings,
2010                                        callback=params.get('callback'),
2011                                        _return_http_data_only=params.get('_return_http_data_only'),
2012                                        _preload_content=params.get('_preload_content', True),
2013                                        _request_timeout=params.get('_request_timeout'),
2014                                        collection_formats=collection_formats)
2015
2016    def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
2017        """
2018        Returns a signature, initials, or stamps image.
2019        
2020        This method makes a synchronous HTTP request by default. To make an
2021        asynchronous HTTP request, please define a `callback` function
2022        to be invoked when receiving the response.
2023        >>> def callback_function(response):
2024        >>>     pprint(response)
2025        >>>
2026        >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
2027
2028        :param callback function: The callback function
2029            for asynchronous request. (optional)
2030        :param str account_id: The external account number (int) or account ID Guid. (required)
2031        :param str image_type: One of **signature_image** or **initials_image**. (required)
2032        :param str signature_id: The ID of the signature being accessed. (required)
2033        :param str include_chrome:
2034        :return: file
2035                 If the method is called asynchronously,
2036                 returns the request thread.
2037        """
2038        kwargs['_return_http_data_only'] = True
2039        if kwargs.get('callback'):
2040            return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2041        else:
2042            (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2043            return data
2044
2045    def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
2046        """
2047        Returns a signature, initials, or stamps image.
2048        
2049        This method makes a synchronous HTTP request by default. To make an
2050        asynchronous HTTP request, please define a `callback` function
2051        to be invoked when receiving the response.
2052        >>> def callback_function(response):
2053        >>>     pprint(response)
2054        >>>
2055        >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
2056
2057        :param callback function: The callback function
2058            for asynchronous request. (optional)
2059        :param str account_id: The external account number (int) or account ID Guid. (required)
2060        :param str image_type: One of **signature_image** or **initials_image**. (required)
2061        :param str signature_id: The ID of the signature being accessed. (required)
2062        :param str include_chrome:
2063        :return: file
2064                 If the method is called asynchronously,
2065                 returns the request thread.
2066        """
2067
2068        all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome']
2069        all_params.append('callback')
2070        all_params.append('_return_http_data_only')
2071        all_params.append('_preload_content')
2072        all_params.append('_request_timeout')
2073
2074        params = locals()
2075        for key, val in iteritems(params['kwargs']):
2076            if key not in all_params:
2077                raise TypeError(
2078                    "Got an unexpected keyword argument '%s'"
2079                    " to method get_account_signature_image" % key
2080                )
2081            params[key] = val
2082        del params['kwargs']
2083        # verify the required parameter 'account_id' is set
2084        if ('account_id' not in params) or (params['account_id'] is None):
2085            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`")
2086        # verify the required parameter 'image_type' is set
2087        if ('image_type' not in params) or (params['image_type'] is None):
2088            raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`")
2089        # verify the required parameter 'signature_id' is set
2090        if ('signature_id' not in params) or (params['signature_id'] is None):
2091            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`")
2092
2093
2094        collection_formats = {}
2095
2096        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
2097        path_params = {}
2098        if 'account_id' in params:
2099            path_params['accountId'] = params['account_id']
2100        if 'image_type' in params:
2101            path_params['imageType'] = params['image_type']
2102        if 'signature_id' in params:
2103            path_params['signatureId'] = params['signature_id']
2104
2105        query_params = {}
2106        if 'include_chrome' in params:
2107            query_params['include_chrome'] = params['include_chrome']
2108
2109        header_params = {}
2110
2111        form_params = []
2112        local_var_files = {}
2113
2114        body_params = None
2115        # HTTP header `Accept`
2116        header_params['Accept'] = self.api_client.\
2117            select_header_accept(['image/gif'])
2118
2119        # Authentication setting
2120        auth_settings = []
2121
2122        return self.api_client.call_api(resource_path, 'GET',
2123                                        path_params,
2124                                        query_params,
2125                                        header_params,
2126                                        body=body_params,
2127                                        post_params=form_params,
2128                                        files=local_var_files,
2129                                        response_type='file',
2130                                        auth_settings=auth_settings,
2131                                        callback=params.get('callback'),
2132                                        _return_http_data_only=params.get('_return_http_data_only'),
2133                                        _preload_content=params.get('_preload_content', True),
2134                                        _request_timeout=params.get('_request_timeout'),
2135                                        collection_formats=collection_formats)
2136
2137    def get_account_signatures(self, account_id, **kwargs):
2138        """
2139        Returns the managed signature definitions for the account
2140        
2141        This method makes a synchronous HTTP request by default. To make an
2142        asynchronous HTTP request, please define a `callback` function
2143        to be invoked when receiving the response.
2144        >>> def callback_function(response):
2145        >>>     pprint(response)
2146        >>>
2147        >>> thread = api.get_account_signatures(account_id, callback=callback_function)
2148
2149        :param callback function: The callback function
2150            for asynchronous request. (optional)
2151        :param str account_id: The external account number (int) or account ID Guid. (required)
2152        :param str stamp_format:
2153        :param str stamp_name:
2154        :param str stamp_type:
2155        :return: AccountSignaturesInformation
2156                 If the method is called asynchronously,
2157                 returns the request thread.
2158        """
2159        kwargs['_return_http_data_only'] = True
2160        if kwargs.get('callback'):
2161            return self.get_account_signatures_with_http_info(account_id, **kwargs)
2162        else:
2163            (data) = self.get_account_signatures_with_http_info(account_id, **kwargs)
2164            return data
2165
2166    def get_account_signatures_with_http_info(self, account_id, **kwargs):
2167        """
2168        Returns the managed signature definitions for the account
2169        
2170        This method makes a synchronous HTTP request by default. To make an
2171        asynchronous HTTP request, please define a `callback` function
2172        to be invoked when receiving the response.
2173        >>> def callback_function(response):
2174        >>>     pprint(response)
2175        >>>
2176        >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function)
2177
2178        :param callback function: The callback function
2179            for asynchronous request. (optional)
2180        :param str account_id: The external account number (int) or account ID Guid. (required)
2181        :param str stamp_format:
2182        :param str stamp_name:
2183        :param str stamp_type:
2184        :return: AccountSignaturesInformation
2185                 If the method is called asynchronously,
2186                 returns the request thread.
2187        """
2188
2189        all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type']
2190        all_params.append('callback')
2191        all_params.append('_return_http_data_only')
2192        all_params.append('_preload_content')
2193        all_params.append('_request_timeout')
2194
2195        params = locals()
2196        for key, val in iteritems(params['kwargs']):
2197            if key not in all_params:
2198                raise TypeError(
2199                    "Got an unexpected keyword argument '%s'"
2200                    " to method get_account_signatures" % key
2201                )
2202            params[key] = val
2203        del params['kwargs']
2204        # verify the required parameter 'account_id' is set
2205        if ('account_id' not in params) or (params['account_id'] is None):
2206            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`")
2207
2208
2209        collection_formats = {}
2210
2211        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
2212        path_params = {}
2213        if 'account_id' in params:
2214            path_params['accountId'] = params['account_id']
2215
2216        query_params = {}
2217        if 'stamp_format' in params:
2218            query_params['stamp_format'] = params['stamp_format']
2219        if 'stamp_name' in params:
2220            query_params['stamp_name'] = params['stamp_name']
2221        if 'stamp_type' in params:
2222            query_params['stamp_type'] = params['stamp_type']
2223
2224        header_params = {}
2225
2226        form_params = []
2227        local_var_files = {}
2228
2229        body_params = None
2230        # HTTP header `Accept`
2231        header_params['Accept'] = self.api_client.\
2232            select_header_accept(['application/json'])
2233
2234        # Authentication setting
2235        auth_settings = []
2236
2237        return self.api_client.call_api(resource_path, 'GET',
2238                                        path_params,
2239                                        query_params,
2240                                        header_params,
2241                                        body=body_params,
2242                                        post_params=form_params,
2243                                        files=local_var_files,
2244                                        response_type='AccountSignaturesInformation',
2245                                        auth_settings=auth_settings,
2246                                        callback=params.get('callback'),
2247                                        _return_http_data_only=params.get('_return_http_data_only'),
2248                                        _preload_content=params.get('_preload_content', True),
2249                                        _request_timeout=params.get('_request_timeout'),
2250                                        collection_formats=collection_formats)
2251
2252    def get_account_tab_settings(self, account_id, **kwargs):
2253        """
2254        Returns tab settings list for specified account
2255        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2256        This method makes a synchronous HTTP request by default. To make an
2257        asynchronous HTTP request, please define a `callback` function
2258        to be invoked when receiving the response.
2259        >>> def callback_function(response):
2260        >>>     pprint(response)
2261        >>>
2262        >>> thread = api.get_account_tab_settings(account_id, callback=callback_function)
2263
2264        :param callback function: The callback function
2265            for asynchronous request. (optional)
2266        :param str account_id: The external account number (int) or account ID Guid. (required)
2267        :return: TabAccountSettings
2268                 If the method is called asynchronously,
2269                 returns the request thread.
2270        """
2271        kwargs['_return_http_data_only'] = True
2272        if kwargs.get('callback'):
2273            return self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2274        else:
2275            (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2276            return data
2277
2278    def get_account_tab_settings_with_http_info(self, account_id, **kwargs):
2279        """
2280        Returns tab settings list for specified account
2281        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2282        This method makes a synchronous HTTP request by default. To make an
2283        asynchronous HTTP request, please define a `callback` function
2284        to be invoked when receiving the response.
2285        >>> def callback_function(response):
2286        >>>     pprint(response)
2287        >>>
2288        >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function)
2289
2290        :param callback function: The callback function
2291            for asynchronous request. (optional)
2292        :param str account_id: The external account number (int) or account ID Guid. (required)
2293        :return: TabAccountSettings
2294                 If the method is called asynchronously,
2295                 returns the request thread.
2296        """
2297
2298        all_params = ['account_id']
2299        all_params.append('callback')
2300        all_params.append('_return_http_data_only')
2301        all_params.append('_preload_content')
2302        all_params.append('_request_timeout')
2303
2304        params = locals()
2305        for key, val in iteritems(params['kwargs']):
2306            if key not in all_params:
2307                raise TypeError(
2308                    "Got an unexpected keyword argument '%s'"
2309                    " to method get_account_tab_settings" % key
2310                )
2311            params[key] = val
2312        del params['kwargs']
2313        # verify the required parameter 'account_id' is set
2314        if ('account_id' not in params) or (params['account_id'] is None):
2315            raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`")
2316
2317
2318        collection_formats = {}
2319
2320        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
2321        path_params = {}
2322        if 'account_id' in params:
2323            path_params['accountId'] = params['account_id']
2324
2325        query_params = {}
2326
2327        header_params = {}
2328
2329        form_params = []
2330        local_var_files = {}
2331
2332        body_params = None
2333        # HTTP header `Accept`
2334        header_params['Accept'] = self.api_client.\
2335            select_header_accept(['application/json'])
2336
2337        # Authentication setting
2338        auth_settings = []
2339
2340        return self.api_client.call_api(resource_path, 'GET',
2341                                        path_params,
2342                                        query_params,
2343                                        header_params,
2344                                        body=body_params,
2345                                        post_params=form_params,
2346                                        files=local_var_files,
2347                                        response_type='TabAccountSettings',
2348                                        auth_settings=auth_settings,
2349                                        callback=params.get('callback'),
2350                                        _return_http_data_only=params.get('_return_http_data_only'),
2351                                        _preload_content=params.get('_preload_content', True),
2352                                        _request_timeout=params.get('_request_timeout'),
2353                                        collection_formats=collection_formats)
2354
2355    def get_all_payment_gateway_accounts(self, account_id, **kwargs):
2356        """
2357        Get all payment gateway account for the provided accountId
2358        This method returns a list of payment gateway accounts and basic information about them.
2359        This method makes a synchronous HTTP request by default. To make an
2360        asynchronous HTTP request, please define a `callback` function
2361        to be invoked when receiving the response.
2362        >>> def callback_function(response):
2363        >>>     pprint(response)
2364        >>>
2365        >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function)
2366
2367        :param callback function: The callback function
2368            for asynchronous request. (optional)
2369        :param str account_id: The external account number (int) or account ID Guid. (required)
2370        :return: PaymentGatewayAccountsInfo
2371                 If the method is called asynchronously,
2372                 returns the request thread.
2373        """
2374        kwargs['_return_http_data_only'] = True
2375        if kwargs.get('callback'):
2376            return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2377        else:
2378            (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2379            return data
2380
2381    def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs):
2382        """
2383        Get all payment gateway account for the provided accountId
2384        This method returns a list of payment gateway accounts and basic information about them.
2385        This method makes a synchronous HTTP request by default. To make an
2386        asynchronous HTTP request, please define a `callback` function
2387        to be invoked when receiving the response.
2388        >>> def callback_function(response):
2389        >>>     pprint(response)
2390        >>>
2391        >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function)
2392
2393        :param callback function: The callback function
2394            for asynchronous request. (optional)
2395        :param str account_id: The external account number (int) or account ID Guid. (required)
2396        :return: PaymentGatewayAccountsInfo
2397                 If the method is called asynchronously,
2398                 returns the request thread.
2399        """
2400
2401        all_params = ['account_id']
2402        all_params.append('callback')
2403        all_params.append('_return_http_data_only')
2404        all_params.append('_preload_content')
2405        all_params.append('_request_timeout')
2406
2407        params = locals()
2408        for key, val in iteritems(params['kwargs']):
2409            if key not in all_params:
2410                raise TypeError(
2411                    "Got an unexpected keyword argument '%s'"
2412                    " to method get_all_payment_gateway_accounts" % key
2413                )
2414            params[key] = val
2415        del params['kwargs']
2416        # verify the required parameter 'account_id' is set
2417        if ('account_id' not in params) or (params['account_id'] is None):
2418            raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`")
2419
2420
2421        collection_formats = {}
2422
2423        resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json')
2424        path_params = {}
2425        if 'account_id' in params:
2426            path_params['accountId'] = params['account_id']
2427
2428        query_params = {}
2429
2430        header_params = {}
2431
2432        form_params = []
2433        local_var_files = {}
2434
2435        body_params = None
2436        # HTTP header `Accept`
2437        header_params['Accept'] = self.api_client.\
2438            select_header_accept(['application/json'])
2439
2440        # Authentication setting
2441        auth_settings = []
2442
2443        return self.api_client.call_api(resource_path, 'GET',
2444                                        path_params,
2445                                        query_params,
2446                                        header_params,
2447                                        body=body_params,
2448                                        post_params=form_params,
2449                                        files=local_var_files,
2450                                        response_type='PaymentGatewayAccountsInfo',
2451                                        auth_settings=auth_settings,
2452                                        callback=params.get('callback'),
2453                                        _return_http_data_only=params.get('_return_http_data_only'),
2454                                        _preload_content=params.get('_preload_content', True),
2455                                        _request_timeout=params.get('_request_timeout'),
2456                                        collection_formats=collection_formats)
2457
2458    def get_billing_charges(self, account_id, **kwargs):
2459        """
2460        Gets list of recurring and usage charges for the account.
2461        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2462        This method makes a synchronous HTTP request by default. To make an
2463        asynchronous HTTP request, please define a `callback` function
2464        to be invoked when receiving the response.
2465        >>> def callback_function(response):
2466        >>>     pprint(response)
2467        >>>
2468        >>> thread = api.get_billing_charges(account_id, callback=callback_function)
2469
2470        :param callback function: The callback function
2471            for asynchronous request. (optional)
2472        :param str account_id: The external account number (int) or account ID Guid. (required)
2473        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2474        :return: BillingChargeResponse
2475                 If the method is called asynchronously,
2476                 returns the request thread.
2477        """
2478        kwargs['_return_http_data_only'] = True
2479        if kwargs.get('callback'):
2480            return self.get_billing_charges_with_http_info(account_id, **kwargs)
2481        else:
2482            (data) = self.get_billing_charges_with_http_info(account_id, **kwargs)
2483            return data
2484
2485    def get_billing_charges_with_http_info(self, account_id, **kwargs):
2486        """
2487        Gets list of recurring and usage charges for the account.
2488        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2489        This method makes a synchronous HTTP request by default. To make an
2490        asynchronous HTTP request, please define a `callback` function
2491        to be invoked when receiving the response.
2492        >>> def callback_function(response):
2493        >>>     pprint(response)
2494        >>>
2495        >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function)
2496
2497        :param callback function: The callback function
2498            for asynchronous request. (optional)
2499        :param str account_id: The external account number (int) or account ID Guid. (required)
2500        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2501        :return: BillingChargeResponse
2502                 If the method is called asynchronously,
2503                 returns the request thread.
2504        """
2505
2506        all_params = ['account_id', 'include_charges']
2507        all_params.append('callback')
2508        all_params.append('_return_http_data_only')
2509        all_params.append('_preload_content')
2510        all_params.append('_request_timeout')
2511
2512        params = locals()
2513        for key, val in iteritems(params['kwargs']):
2514            if key not in all_params:
2515                raise TypeError(
2516                    "Got an unexpected keyword argument '%s'"
2517                    " to method get_billing_charges" % key
2518                )
2519            params[key] = val
2520        del params['kwargs']
2521        # verify the required parameter 'account_id' is set
2522        if ('account_id' not in params) or (params['account_id'] is None):
2523            raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`")
2524
2525
2526        collection_formats = {}
2527
2528        resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json')
2529        path_params = {}
2530        if 'account_id' in params:
2531            path_params['accountId'] = params['account_id']
2532
2533        query_params = {}
2534        if 'include_charges' in params:
2535            query_params['include_charges'] = params['include_charges']
2536
2537        header_params = {}
2538
2539        form_params = []
2540        local_var_files = {}
2541
2542        body_params = None
2543        # HTTP header `Accept`
2544        header_params['Accept'] = self.api_client.\
2545            select_header_accept(['application/json'])
2546
2547        # Authentication setting
2548        auth_settings = []
2549
2550        return self.api_client.call_api(resource_path, 'GET',
2551                                        path_params,
2552                                        query_params,
2553                                        header_params,
2554                                        body=body_params,
2555                                        post_params=form_params,
2556                                        files=local_var_files,
2557                                        response_type='BillingChargeResponse',
2558                                        auth_settings=auth_settings,
2559                                        callback=params.get('callback'),
2560                                        _return_http_data_only=params.get('_return_http_data_only'),
2561                                        _preload_content=params.get('_preload_content', True),
2562                                        _request_timeout=params.get('_request_timeout'),
2563                                        collection_formats=collection_formats)
2564
2565    def get_brand(self, account_id, brand_id, **kwargs):
2566        """
2567        Get information for a specific brand.
2568        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2569        This method makes a synchronous HTTP request by default. To make an
2570        asynchronous HTTP request, please define a `callback` function
2571        to be invoked when receiving the response.
2572        >>> def callback_function(response):
2573        >>>     pprint(response)
2574        >>>
2575        >>> thread = api.get_brand(account_id, brand_id, callback=callback_function)
2576
2577        :param callback function: The callback function
2578            for asynchronous request. (optional)
2579        :param str account_id: The external account number (int) or account ID Guid. (required)
2580        :param str brand_id: The unique identifier of a brand. (required)
2581        :param str include_external_references:
2582        :param str include_logos:
2583        :return: Brand
2584                 If the method is called asynchronously,
2585                 returns the request thread.
2586        """
2587        kwargs['_return_http_data_only'] = True
2588        if kwargs.get('callback'):
2589            return self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2590        else:
2591            (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2592            return data
2593
2594    def get_brand_with_http_info(self, account_id, brand_id, **kwargs):
2595        """
2596        Get information for a specific brand.
2597        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2598        This method makes a synchronous HTTP request by default. To make an
2599        asynchronous HTTP request, please define a `callback` function
2600        to be invoked when receiving the response.
2601        >>> def callback_function(response):
2602        >>>     pprint(response)
2603        >>>
2604        >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function)
2605
2606        :param callback function: The callback function
2607            for asynchronous request. (optional)
2608        :param str account_id: The external account number (int) or account ID Guid. (required)
2609        :param str brand_id: The unique identifier of a brand. (required)
2610        :param str include_external_references:
2611        :param str include_logos:
2612        :return: Brand
2613                 If the method is called asynchronously,
2614                 returns the request thread.
2615        """
2616
2617        all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos']
2618        all_params.append('callback')
2619        all_params.append('_return_http_data_only')
2620        all_params.append('_preload_content')
2621        all_params.append('_request_timeout')
2622
2623        params = locals()
2624        for key, val in iteritems(params['kwargs']):
2625            if key not in all_params:
2626                raise TypeError(
2627                    "Got an unexpected keyword argument '%s'"
2628                    " to method get_brand" % key
2629                )
2630            params[key] = val
2631        del params['kwargs']
2632        # verify the required parameter 'account_id' is set
2633        if ('account_id' not in params) or (params['account_id'] is None):
2634            raise ValueError("Missing the required parameter `account_id` when calling `get_brand`")
2635        # verify the required parameter 'brand_id' is set
2636        if ('brand_id' not in params) or (params['brand_id'] is None):
2637            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`")
2638
2639
2640        collection_formats = {}
2641
2642        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
2643        path_params = {}
2644        if 'account_id' in params:
2645            path_params['accountId'] = params['account_id']
2646        if 'brand_id' in params:
2647            path_params['brandId'] = params['brand_id']
2648
2649        query_params = {}
2650        if 'include_external_references' in params:
2651            query_params['include_external_references'] = params['include_external_references']
2652        if 'include_logos' in params:
2653            query_params['include_logos'] = params['include_logos']
2654
2655        header_params = {}
2656
2657        form_params = []
2658        local_var_files = {}
2659
2660        body_params = None
2661        # HTTP header `Accept`
2662        header_params['Accept'] = self.api_client.\
2663            select_header_accept(['application/json'])
2664
2665        # Authentication setting
2666        auth_settings = []
2667
2668        return self.api_client.call_api(resource_path, 'GET',
2669                                        path_params,
2670                                        query_params,
2671                                        header_params,
2672                                        body=body_params,
2673                                        post_params=form_params,
2674                                        files=local_var_files,
2675                                        response_type='Brand',
2676                                        auth_settings=auth_settings,
2677                                        callback=params.get('callback'),
2678                                        _return_http_data_only=params.get('_return_http_data_only'),
2679                                        _preload_content=params.get('_preload_content', True),
2680                                        _request_timeout=params.get('_request_timeout'),
2681                                        collection_formats=collection_formats)
2682
2683    def get_brand_export_file(self, account_id, brand_id, **kwargs):
2684        """
2685        Export a specific brand.
2686        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2687        This method makes a synchronous HTTP request by default. To make an
2688        asynchronous HTTP request, please define a `callback` function
2689        to be invoked when receiving the response.
2690        >>> def callback_function(response):
2691        >>>     pprint(response)
2692        >>>
2693        >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function)
2694
2695        :param callback function: The callback function
2696            for asynchronous request. (optional)
2697        :param str account_id: The external account number (int) or account ID Guid. (required)
2698        :param str brand_id: The unique identifier of a brand. (required)
2699        :return: None
2700                 If the method is called asynchronously,
2701                 returns the request thread.
2702        """
2703        kwargs['_return_http_data_only'] = True
2704        if kwargs.get('callback'):
2705            return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2706        else:
2707            (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2708            return data
2709
2710    def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs):
2711        """
2712        Export a specific brand.
2713        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2714        This method makes a synchronous HTTP request by default. To make an
2715        asynchronous HTTP request, please define a `callback` function
2716        to be invoked when receiving the response.
2717        >>> def callback_function(response):
2718        >>>     pprint(response)
2719        >>>
2720        >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
2721
2722        :param callback function: The callback function
2723            for asynchronous request. (optional)
2724        :param str account_id: The external account number (int) or account ID Guid. (required)
2725        :param str brand_id: The unique identifier of a brand. (required)
2726        :return: None
2727                 If the method is called asynchronously,
2728                 returns the request thread.
2729        """
2730
2731        all_params = ['account_id', 'brand_id']
2732        all_params.append('callback')
2733        all_params.append('_return_http_data_only')
2734        all_params.append('_preload_content')
2735        all_params.append('_request_timeout')
2736
2737        params = locals()
2738        for key, val in iteritems(params['kwargs']):
2739            if key not in all_params:
2740                raise TypeError(
2741                    "Got an unexpected keyword argument '%s'"
2742                    " to method get_brand_export_file" % key
2743                )
2744            params[key] = val
2745        del params['kwargs']
2746        # verify the required parameter 'account_id' is set
2747        if ('account_id' not in params) or (params['account_id'] is None):
2748            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`")
2749        # verify the required parameter 'brand_id' is set
2750        if ('brand_id' not in params) or (params['brand_id'] is None):
2751            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`")
2752
2753
2754        collection_formats = {}
2755
2756        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json')
2757        path_params = {}
2758        if 'account_id' in params:
2759            path_params['accountId'] = params['account_id']
2760        if 'brand_id' in params:
2761            path_params['brandId'] = params['brand_id']
2762
2763        query_params = {}
2764
2765        header_params = {}
2766
2767        form_params = []
2768        local_var_files = {}
2769
2770        body_params = None
2771        # HTTP header `Accept`
2772        header_params['Accept'] = self.api_client.\
2773            select_header_accept(['application/json'])
2774
2775        # Authentication setting
2776        auth_settings = []
2777
2778        return self.api_client.call_api(resource_path, 'GET',
2779                                        path_params,
2780                                        query_params,
2781                                        header_params,
2782                                        body=body_params,
2783                                        post_params=form_params,
2784                                        files=local_var_files,
2785                                        response_type=None,
2786                                        auth_settings=auth_settings,
2787                                        callback=params.get('callback'),
2788                                        _return_http_data_only=params.get('_return_http_data_only'),
2789                                        _preload_content=params.get('_preload_content', True),
2790                                        _request_timeout=params.get('_request_timeout'),
2791                                        collection_formats=collection_formats)
2792
2793    def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
2794        """
2795        Obtains the specified image for a brand.
2796        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2797        This method makes a synchronous HTTP request by default. To make an
2798        asynchronous HTTP request, please define a `callback` function
2799        to be invoked when receiving the response.
2800        >>> def callback_function(response):
2801        >>>     pprint(response)
2802        >>>
2803        >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
2804
2805        :param callback function: The callback function
2806            for asynchronous request. (optional)
2807        :param str account_id: The external account number (int) or account ID Guid. (required)
2808        :param str brand_id: The unique identifier of a brand. (required)
2809        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2810        :return: file
2811                 If the method is called asynchronously,
2812                 returns the request thread.
2813        """
2814        kwargs['_return_http_data_only'] = True
2815        if kwargs.get('callback'):
2816            return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2817        else:
2818            (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2819            return data
2820
2821    def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
2822        """
2823        Obtains the specified image for a brand.
2824        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2825        This method makes a synchronous HTTP request by default. To make an
2826        asynchronous HTTP request, please define a `callback` function
2827        to be invoked when receiving the response.
2828        >>> def callback_function(response):
2829        >>>     pprint(response)
2830        >>>
2831        >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
2832
2833        :param callback function: The callback function
2834            for asynchronous request. (optional)
2835        :param str account_id: The external account number (int) or account ID Guid. (required)
2836        :param str brand_id: The unique identifier of a brand. (required)
2837        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2838        :return: file
2839                 If the method is called asynchronously,
2840                 returns the request thread.
2841        """
2842
2843        all_params = ['account_id', 'brand_id', 'logo_type']
2844        all_params.append('callback')
2845        all_params.append('_return_http_data_only')
2846        all_params.append('_preload_content')
2847        all_params.append('_request_timeout')
2848
2849        params = locals()
2850        for key, val in iteritems(params['kwargs']):
2851            if key not in all_params:
2852                raise TypeError(
2853                    "Got an unexpected keyword argument '%s'"
2854                    " to method get_brand_logo_by_type" % key
2855                )
2856            params[key] = val
2857        del params['kwargs']
2858        # verify the required parameter 'account_id' is set
2859        if ('account_id' not in params) or (params['account_id'] is None):
2860            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`")
2861        # verify the required parameter 'brand_id' is set
2862        if ('brand_id' not in params) or (params['brand_id'] is None):
2863            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`")
2864        # verify the required parameter 'logo_type' is set
2865        if ('logo_type' not in params) or (params['logo_type'] is None):
2866            raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`")
2867
2868
2869        collection_formats = {}
2870
2871        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
2872        path_params = {}
2873        if 'account_id' in params:
2874            path_params['accountId'] = params['account_id']
2875        if 'brand_id' in params:
2876            path_params['brandId'] = params['brand_id']
2877        if 'logo_type' in params:
2878            path_params['logoType'] = params['logo_type']
2879
2880        query_params = {}
2881
2882        header_params = {}
2883
2884        form_params = []
2885        local_var_files = {}
2886
2887        body_params = None
2888        # HTTP header `Accept`
2889        header_params['Accept'] = self.api_client.\
2890            select_header_accept(['image/png'])
2891
2892        # Authentication setting
2893        auth_settings = []
2894
2895        return self.api_client.call_api(resource_path, 'GET',
2896                                        path_params,
2897                                        query_params,
2898                                        header_params,
2899                                        body=body_params,
2900                                        post_params=form_params,
2901                                        files=local_var_files,
2902                                        response_type='file',
2903                                        auth_settings=auth_settings,
2904                                        callback=params.get('callback'),
2905                                        _return_http_data_only=params.get('_return_http_data_only'),
2906                                        _preload_content=params.get('_preload_content', True),
2907                                        _request_timeout=params.get('_request_timeout'),
2908                                        collection_formats=collection_formats)
2909
2910    def get_brand_resources(self, account_id, brand_id, **kwargs):
2911        """
2912        Returns the specified account's list of branding resources (metadata).
2913        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2914        This method makes a synchronous HTTP request by default. To make an
2915        asynchronous HTTP request, please define a `callback` function
2916        to be invoked when receiving the response.
2917        >>> def callback_function(response):
2918        >>>     pprint(response)
2919        >>>
2920        >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function)
2921
2922        :param callback function: The callback function
2923            for asynchronous request. (optional)
2924        :param str account_id: The external account number (int) or account ID Guid. (required)
2925        :param str brand_id: The unique identifier of a brand. (required)
2926        :return: BrandResourcesList
2927                 If the method is called asynchronously,
2928                 returns the request thread.
2929        """
2930        kwargs['_return_http_data_only'] = True
2931        if kwargs.get('callback'):
2932            return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2933        else:
2934            (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2935            return data
2936
2937    def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs):
2938        """
2939        Returns the specified account's list of branding resources (metadata).
2940        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2941        This method makes a synchronous HTTP request by default. To make an
2942        asynchronous HTTP request, please define a `callback` function
2943        to be invoked when receiving the response.
2944        >>> def callback_function(response):
2945        >>>     pprint(response)
2946        >>>
2947        >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
2948
2949        :param callback function: The callback function
2950            for asynchronous request. (optional)
2951        :param str account_id: The external account number (int) or account ID Guid. (required)
2952        :param str brand_id: The unique identifier of a brand. (required)
2953        :return: BrandResourcesList
2954                 If the method is called asynchronously,
2955                 returns the request thread.
2956        """
2957
2958        all_params = ['account_id', 'brand_id']
2959        all_params.append('callback')
2960        all_params.append('_return_http_data_only')
2961        all_params.append('_preload_content')
2962        all_params.append('_request_timeout')
2963
2964        params = locals()
2965        for key, val in iteritems(params['kwargs']):
2966            if key not in all_params:
2967                raise TypeError(
2968                    "Got an unexpected keyword argument '%s'"
2969                    " to method get_brand_resources" % key
2970                )
2971            params[key] = val
2972        del params['kwargs']
2973        # verify the required parameter 'account_id' is set
2974        if ('account_id' not in params) or (params['account_id'] is None):
2975            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`")
2976        # verify the required parameter 'brand_id' is set
2977        if ('brand_id' not in params) or (params['brand_id'] is None):
2978            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`")
2979
2980
2981        collection_formats = {}
2982
2983        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json')
2984        path_params = {}
2985        if 'account_id' in params:
2986            path_params['accountId'] = params['account_id']
2987        if 'brand_id' in params:
2988            path_params['brandId'] = params['brand_id']
2989
2990        query_params = {}
2991
2992        header_params = {}
2993
2994        form_params = []
2995        local_var_files = {}
2996
2997        body_params = None
2998        # HTTP header `Accept`
2999        header_params['Accept'] = self.api_client.\
3000            select_header_accept(['application/json'])
3001
3002        # Authentication setting
3003        auth_settings = []
3004
3005        return self.api_client.call_api(resource_path, 'GET',
3006                                        path_params,
3007                                        query_params,
3008                                        header_params,
3009                                        body=body_params,
3010                                        post_params=form_params,
3011                                        files=local_var_files,
3012                                        response_type='BrandResourcesList',
3013                                        auth_settings=auth_settings,
3014                                        callback=params.get('callback'),
3015                                        _return_http_data_only=params.get('_return_http_data_only'),
3016                                        _preload_content=params.get('_preload_content', True),
3017                                        _request_timeout=params.get('_request_timeout'),
3018                                        collection_formats=collection_formats)
3019
3020    def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs):
3021        """
3022        Returns the specified branding resource file.
3023        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3024        This method makes a synchronous HTTP request by default. To make an
3025        asynchronous HTTP request, please define a `callback` function
3026        to be invoked when receiving the response.
3027        >>> def callback_function(response):
3028        >>>     pprint(response)
3029        >>>
3030        >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
3031
3032        :param callback function: The callback function
3033            for asynchronous request. (optional)
3034        :param str account_id: The external account number (int) or account ID Guid. (required)
3035        :param str brand_id: The unique identifier of a brand. (required)
3036        :param str resource_content_type: (required)
3037        :param str langcode:
3038        :param str return_master:
3039        :return: None
3040                 If the method is called asynchronously,
3041                 returns the request thread.
3042        """
3043        kwargs['_return_http_data_only'] = True
3044        if kwargs.get('callback'):
3045            return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3046        else:
3047            (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3048            return data
3049
3050    def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs):
3051        """
3052        Returns the specified branding resource file.
3053        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3054        This method makes a synchronous HTTP request by default. To make an
3055        asynchronous HTTP request, please define a `callback` function
3056        to be invoked when receiving the response.
3057        >>> def callback_function(response):
3058        >>>     pprint(response)
3059        >>>
3060        >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
3061
3062        :param callback function: The callback function
3063            for asynchronous request. (optional)
3064        :param str account_id: The external account number (int) or account ID Guid. (required)
3065        :param str brand_id: The unique identifier of a brand. (required)
3066        :param str resource_content_type: (required)
3067        :param str langcode:
3068        :param str return_master:
3069        :return: None
3070                 If the method is called asynchronously,
3071                 returns the request thread.
3072        """
3073
3074        all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master']
3075        all_params.append('callback')
3076        all_params.append('_return_http_data_only')
3077        all_params.append('_preload_content')
3078        all_params.append('_request_timeout')
3079
3080        params = locals()
3081        for key, val in iteritems(params['kwargs']):
3082            if key not in all_params:
3083                raise TypeError(
3084                    "Got an unexpected keyword argument '%s'"
3085                    " to method get_brand_resources_by_content_type" % key
3086                )
3087            params[key] = val
3088        del params['kwargs']
3089        # verify the required parameter 'account_id' is set
3090        if ('account_id' not in params) or (params['account_id'] is None):
3091            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`")
3092        # verify the required parameter 'brand_id' is set
3093        if ('brand_id' not in params) or (params['brand_id'] is None):
3094            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`")
3095        # verify the required parameter 'resource_content_type' is set
3096        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
3097            raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`")
3098
3099
3100        collection_formats = {}
3101
3102        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
3103        path_params = {}
3104        if 'account_id' in params:
3105            path_params['accountId'] = params['account_id']
3106        if 'brand_id' in params:
3107            path_params['brandId'] = params['brand_id']
3108        if 'resource_content_type' in params:
3109            path_params['resourceContentType'] = params['resource_content_type']
3110
3111        query_params = {}
3112        if 'langcode' in params:
3113            query_params['langcode'] = params['langcode']
3114        if 'return_master' in params:
3115            query_params['return_master'] = params['return_master']
3116
3117        header_params = {}
3118
3119        form_params = []
3120        local_var_files = {}
3121
3122        body_params = None
3123        # HTTP header `Accept`
3124        header_params['Accept'] = self.api_client.\
3125            select_header_accept(['application/json'])
3126
3127        # Authentication setting
3128        auth_settings = []
3129
3130        return self.api_client.call_api(resource_path, 'GET',
3131                                        path_params,
3132                                        query_params,
3133                                        header_params,
3134                                        body=body_params,
3135                                        post_params=form_params,
3136                                        files=local_var_files,
3137                                        response_type=None,
3138                                        auth_settings=auth_settings,
3139                                        callback=params.get('callback'),
3140                                        _return_http_data_only=params.get('_return_http_data_only'),
3141                                        _preload_content=params.get('_preload_content', True),
3142                                        _request_timeout=params.get('_request_timeout'),
3143                                        collection_formats=collection_formats)
3144
3145    def get_consumer_disclosure(self, account_id, lang_code, **kwargs):
3146        """
3147        Gets the Electronic Record and Signature Disclosure.
3148        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3149        This method makes a synchronous HTTP request by default. To make an
3150        asynchronous HTTP request, please define a `callback` function
3151        to be invoked when receiving the response.
3152        >>> def callback_function(response):
3153        >>>     pprint(response)
3154        >>>
3155        >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function)
3156
3157        :param callback function: The callback function
3158            for asynchronous request. (optional)
3159        :param str account_id: The external account number (int) or account ID Guid. (required)
3160        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3161        :return: ConsumerDisclosure
3162                 If the method is called asynchronously,
3163                 returns the request thread.
3164        """
3165        kwargs['_return_http_data_only'] = True
3166        if kwargs.get('callback'):
3167            return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3168        else:
3169            (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3170            return data
3171
3172    def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
3173        """
3174        Gets the Electronic Record and Signature Disclosure.
3175        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3176        This method makes a synchronous HTTP request by default. To make an
3177        asynchronous HTTP request, please define a `callback` function
3178        to be invoked when receiving the response.
3179        >>> def callback_function(response):
3180        >>>     pprint(response)
3181        >>>
3182        >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
3183
3184        :param callback function: The callback function
3185            for asynchronous request. (optional)
3186        :param str account_id: The external account number (int) or account ID Guid. (required)
3187        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3188        :return: ConsumerDisclosure
3189                 If the method is called asynchronously,
3190                 returns the request thread.
3191        """
3192
3193        all_params = ['account_id', 'lang_code']
3194        all_params.append('callback')
3195        all_params.append('_return_http_data_only')
3196        all_params.append('_preload_content')
3197        all_params.append('_request_timeout')
3198
3199        params = locals()
3200        for key, val in iteritems(params['kwargs']):
3201            if key not in all_params:
3202                raise TypeError(
3203                    "Got an unexpected keyword argument '%s'"
3204                    " to method get_consumer_disclosure" % key
3205                )
3206            params[key] = val
3207        del params['kwargs']
3208        # verify the required parameter 'account_id' is set
3209        if ('account_id' not in params) or (params['account_id'] is None):
3210            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`")
3211        # verify the required parameter 'lang_code' is set
3212        if ('lang_code' not in params) or (params['lang_code'] is None):
3213            raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`")
3214
3215
3216        collection_formats = {}
3217
3218        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
3219        path_params = {}
3220        if 'account_id' in params:
3221            path_params['accountId'] = params['account_id']
3222        if 'lang_code' in params:
3223            path_params['langCode'] = params['lang_code']
3224
3225        query_params = {}
3226
3227        header_params = {}
3228
3229        form_params = []
3230        local_var_files = {}
3231
3232        body_params = None
3233        # HTTP header `Accept`
3234        header_params['Accept'] = self.api_client.\
3235            select_header_accept(['application/json'])
3236
3237        # Authentication setting
3238        auth_settings = []
3239
3240        return self.api_client.call_api(resource_path, 'GET',
3241                                        path_params,
3242                                        query_params,
3243                                        header_params,
3244                                        body=body_params,
3245                                        post_params=form_params,
3246                                        files=local_var_files,
3247                                        response_type='ConsumerDisclosure',
3248                                        auth_settings=auth_settings,
3249                                        callback=params.get('callback'),
3250                                        _return_http_data_only=params.get('_return_http_data_only'),
3251                                        _preload_content=params.get('_preload_content', True),
3252                                        _request_timeout=params.get('_request_timeout'),
3253                                        collection_formats=collection_formats)
3254
3255    def get_consumer_disclosure_default(self, account_id, **kwargs):
3256        """
3257        Gets the Electronic Record and Signature Disclosure for the account.
3258        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3259        This method makes a synchronous HTTP request by default. To make an
3260        asynchronous HTTP request, please define a `callback` function
3261        to be invoked when receiving the response.
3262        >>> def callback_function(response):
3263        >>>     pprint(response)
3264        >>>
3265        >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function)
3266
3267        :param callback function: The callback function
3268            for asynchronous request. (optional)
3269        :param str account_id: The external account number (int) or account ID Guid. (required)
3270        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3271        :return: ConsumerDisclosure
3272                 If the method is called asynchronously,
3273                 returns the request thread.
3274        """
3275        kwargs['_return_http_data_only'] = True
3276        if kwargs.get('callback'):
3277            return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3278        else:
3279            (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3280            return data
3281
3282    def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs):
3283        """
3284        Gets the Electronic Record and Signature Disclosure for the account.
3285        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3286        This method makes a synchronous HTTP request by default. To make an
3287        asynchronous HTTP request, please define a `callback` function
3288        to be invoked when receiving the response.
3289        >>> def callback_function(response):
3290        >>>     pprint(response)
3291        >>>
3292        >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function)
3293
3294        :param callback function: The callback function
3295            for asynchronous request. (optional)
3296        :param str account_id: The external account number (int) or account ID Guid. (required)
3297        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3298        :return: ConsumerDisclosure
3299                 If the method is called asynchronously,
3300                 returns the request thread.
3301        """
3302
3303        all_params = ['account_id', 'lang_code']
3304        all_params.append('callback')
3305        all_params.append('_return_http_data_only')
3306        all_params.append('_preload_content')
3307        all_params.append('_request_timeout')
3308
3309        params = locals()
3310        for key, val in iteritems(params['kwargs']):
3311            if key not in all_params:
3312                raise TypeError(
3313                    "Got an unexpected keyword argument '%s'"
3314                    " to method get_consumer_disclosure_default" % key
3315                )
3316            params[key] = val
3317        del params['kwargs']
3318        # verify the required parameter 'account_id' is set
3319        if ('account_id' not in params) or (params['account_id'] is None):
3320            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`")
3321
3322
3323        collection_formats = {}
3324
3325        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json')
3326        path_params = {}
3327        if 'account_id' in params:
3328            path_params['accountId'] = params['account_id']
3329
3330        query_params = {}
3331        if 'lang_code' in params:
3332            query_params['langCode'] = params['lang_code']
3333
3334        header_params = {}
3335
3336        form_params = []
3337        local_var_files = {}
3338
3339        body_params = None
3340        # HTTP header `Accept`
3341        header_params['Accept'] = self.api_client.\
3342            select_header_accept(['application/json'])
3343
3344        # Authentication setting
3345        auth_settings = []
3346
3347        return self.api_client.call_api(resource_path, 'GET',
3348                                        path_params,
3349                                        query_params,
3350                                        header_params,
3351                                        body=body_params,
3352                                        post_params=form_params,
3353                                        files=local_var_files,
3354                                        response_type='ConsumerDisclosure',
3355                                        auth_settings=auth_settings,
3356                                        callback=params.get('callback'),
3357                                        _return_http_data_only=params.get('_return_http_data_only'),
3358                                        _preload_content=params.get('_preload_content', True),
3359                                        _request_timeout=params.get('_request_timeout'),
3360                                        collection_formats=collection_formats)
3361
3362    def get_e_note_configuration(self, account_id, **kwargs):
3363        """
3364        Returns the configuration information for the eNote eOriginal integration.
3365        
3366        This method makes a synchronous HTTP request by default. To make an
3367        asynchronous HTTP request, please define a `callback` function
3368        to be invoked when receiving the response.
3369        >>> def callback_function(response):
3370        >>>     pprint(response)
3371        >>>
3372        >>> thread = api.get_e_note_configuration(account_id, callback=callback_function)
3373
3374        :param callback function: The callback function
3375            for asynchronous request. (optional)
3376        :param str account_id: The external account number (int) or account ID Guid. (required)
3377        :return: ENoteConfiguration
3378                 If the method is called asynchronously,
3379                 returns the request thread.
3380        """
3381        kwargs['_return_http_data_only'] = True
3382        if kwargs.get('callback'):
3383            return self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3384        else:
3385            (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3386            return data
3387
3388    def get_e_note_configuration_with_http_info(self, account_id, **kwargs):
3389        """
3390        Returns the configuration information for the eNote eOriginal integration.
3391        
3392        This method makes a synchronous HTTP request by default. To make an
3393        asynchronous HTTP request, please define a `callback` function
3394        to be invoked when receiving the response.
3395        >>> def callback_function(response):
3396        >>>     pprint(response)
3397        >>>
3398        >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function)
3399
3400        :param callback function: The callback function
3401            for asynchronous request. (optional)
3402        :param str account_id: The external account number (int) or account ID Guid. (required)
3403        :return: ENoteConfiguration
3404                 If the method is called asynchronously,
3405                 returns the request thread.
3406        """
3407
3408        all_params = ['account_id']
3409        all_params.append('callback')
3410        all_params.append('_return_http_data_only')
3411        all_params.append('_preload_content')
3412        all_params.append('_request_timeout')
3413
3414        params = locals()
3415        for key, val in iteritems(params['kwargs']):
3416            if key not in all_params:
3417                raise TypeError(
3418                    "Got an unexpected keyword argument '%s'"
3419                    " to method get_e_note_configuration" % key
3420                )
3421            params[key] = val
3422        del params['kwargs']
3423        # verify the required parameter 'account_id' is set
3424        if ('account_id' not in params) or (params['account_id'] is None):
3425            raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`")
3426
3427
3428        collection_formats = {}
3429
3430        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
3431        path_params = {}
3432        if 'account_id' in params:
3433            path_params['accountId'] = params['account_id']
3434
3435        query_params = {}
3436
3437        header_params = {}
3438
3439        form_params = []
3440        local_var_files = {}
3441
3442        body_params = None
3443        # HTTP header `Accept`
3444        header_params['Accept'] = self.api_client.\
3445            select_header_accept(['application/json'])
3446
3447        # Authentication setting
3448        auth_settings = []
3449
3450        return self.api_client.call_api(resource_path, 'GET',
3451                                        path_params,
3452                                        query_params,
3453                                        header_params,
3454                                        body=body_params,
3455                                        post_params=form_params,
3456                                        files=local_var_files,
3457                                        response_type='ENoteConfiguration',
3458                                        auth_settings=auth_settings,
3459                                        callback=params.get('callback'),
3460                                        _return_http_data_only=params.get('_return_http_data_only'),
3461                                        _preload_content=params.get('_preload_content', True),
3462                                        _request_timeout=params.get('_request_timeout'),
3463                                        collection_formats=collection_formats)
3464
3465    def get_envelope_purge_configuration(self, account_id, **kwargs):
3466        """
3467        Select envelope purge configuration.
3468        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3469        This method makes a synchronous HTTP request by default. To make an
3470        asynchronous HTTP request, please define a `callback` function
3471        to be invoked when receiving the response.
3472        >>> def callback_function(response):
3473        >>>     pprint(response)
3474        >>>
3475        >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function)
3476
3477        :param callback function: The callback function
3478            for asynchronous request. (optional)
3479        :param str account_id: The external account number (int) or account ID Guid. (required)
3480        :return: EnvelopePurgeConfiguration
3481                 If the method is called asynchronously,
3482                 returns the request thread.
3483        """
3484        kwargs['_return_http_data_only'] = True
3485        if kwargs.get('callback'):
3486            return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3487        else:
3488            (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3489            return data
3490
3491    def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
3492        """
3493        Select envelope purge configuration.
3494        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3495        This method makes a synchronous HTTP request by default. To make an
3496        asynchronous HTTP request, please define a `callback` function
3497        to be invoked when receiving the response.
3498        >>> def callback_function(response):
3499        >>>     pprint(response)
3500        >>>
3501        >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
3502
3503        :param callback function: The callback function
3504            for asynchronous request. (optional)
3505        :param str account_id: The external account number (int) or account ID Guid. (required)
3506        :return: EnvelopePurgeConfiguration
3507                 If the method is called asynchronously,
3508                 returns the request thread.
3509        """
3510
3511        all_params = ['account_id']
3512        all_params.append('callback')
3513        all_params.append('_return_http_data_only')
3514        all_params.append('_preload_content')
3515        all_params.append('_request_timeout')
3516
3517        params = locals()
3518        for key, val in iteritems(params['kwargs']):
3519            if key not in all_params:
3520                raise TypeError(
3521                    "Got an unexpected keyword argument '%s'"
3522                    " to method get_envelope_purge_configuration" % key
3523                )
3524            params[key] = val
3525        del params['kwargs']
3526        # verify the required parameter 'account_id' is set
3527        if ('account_id' not in params) or (params['account_id'] is None):
3528            raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`")
3529
3530
3531        collection_formats = {}
3532
3533        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
3534        path_params = {}
3535        if 'account_id' in params:
3536            path_params['accountId'] = params['account_id']
3537
3538        query_params = {}
3539
3540        header_params = {}
3541
3542        form_params = []
3543        local_var_files = {}
3544
3545        body_params = None
3546        # HTTP header `Accept`
3547        header_params['Accept'] = self.api_client.\
3548            select_header_accept(['application/json'])
3549
3550        # Authentication setting
3551        auth_settings = []
3552
3553        return self.api_client.call_api(resource_path, 'GET',
3554                                        path_params,
3555                                        query_params,
3556                                        header_params,
3557                                        body=body_params,
3558                                        post_params=form_params,
3559                                        files=local_var_files,
3560                                        response_type='EnvelopePurgeConfiguration',
3561                                        auth_settings=auth_settings,
3562                                        callback=params.get('callback'),
3563                                        _return_http_data_only=params.get('_return_http_data_only'),
3564                                        _preload_content=params.get('_preload_content', True),
3565                                        _request_timeout=params.get('_request_timeout'),
3566                                        collection_formats=collection_formats)
3567
3568    def get_favorite_templates(self, account_id, **kwargs):
3569        """
3570        Retrieves the list of favorited templates for this caller
3571        
3572        This method makes a synchronous HTTP request by default. To make an
3573        asynchronous HTTP request, please define a `callback` function
3574        to be invoked when receiving the response.
3575        >>> def callback_function(response):
3576        >>>     pprint(response)
3577        >>>
3578        >>> thread = api.get_favorite_templates(account_id, callback=callback_function)
3579
3580        :param callback function: The callback function
3581            for asynchronous request. (optional)
3582        :param str account_id: The external account number (int) or account ID Guid. (required)
3583        :return: FavoriteTemplatesInfo
3584                 If the method is called asynchronously,
3585                 returns the request thread.
3586        """
3587        kwargs['_return_http_data_only'] = True
3588        if kwargs.get('callback'):
3589            return self.get_favorite_templates_with_http_info(account_id, **kwargs)
3590        else:
3591            (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs)
3592            return data
3593
3594    def get_favorite_templates_with_http_info(self, account_id, **kwargs):
3595        """
3596        Retrieves the list of favorited templates for this caller
3597        
3598        This method makes a synchronous HTTP request by default. To make an
3599        asynchronous HTTP request, please define a `callback` function
3600        to be invoked when receiving the response.
3601        >>> def callback_function(response):
3602        >>>     pprint(response)
3603        >>>
3604        >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function)
3605
3606        :param callback function: The callback function
3607            for asynchronous request. (optional)
3608        :param str account_id: The external account number (int) or account ID Guid. (required)
3609        :return: FavoriteTemplatesInfo
3610                 If the method is called asynchronously,
3611                 returns the request thread.
3612        """
3613
3614        all_params = ['account_id']
3615        all_params.append('callback')
3616        all_params.append('_return_http_data_only')
3617        all_params.append('_preload_content')
3618        all_params.append('_request_timeout')
3619
3620        params = locals()
3621        for key, val in iteritems(params['kwargs']):
3622            if key not in all_params:
3623                raise TypeError(
3624                    "Got an unexpected keyword argument '%s'"
3625                    " to method get_favorite_templates" % key
3626                )
3627            params[key] = val
3628        del params['kwargs']
3629        # verify the required parameter 'account_id' is set
3630        if ('account_id' not in params) or (params['account_id'] is None):
3631            raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`")
3632
3633
3634        collection_formats = {}
3635
3636        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
3637        path_params = {}
3638        if 'account_id' in params:
3639            path_params['accountId'] = params['account_id']
3640
3641        query_params = {}
3642
3643        header_params = {}
3644
3645        form_params = []
3646        local_var_files = {}
3647
3648        body_params = None
3649        # HTTP header `Accept`
3650        header_params['Accept'] = self.api_client.\
3651            select_header_accept(['application/json'])
3652
3653        # Authentication setting
3654        auth_settings = []
3655
3656        return self.api_client.call_api(resource_path, 'GET',
3657                                        path_params,
3658                                        query_params,
3659                                        header_params,
3660                                        body=body_params,
3661                                        post_params=form_params,
3662                                        files=local_var_files,
3663                                        response_type='FavoriteTemplatesInfo',
3664                                        auth_settings=auth_settings,
3665                                        callback=params.get('callback'),
3666                                        _return_http_data_only=params.get('_return_http_data_only'),
3667                                        _preload_content=params.get('_preload_content', True),
3668                                        _request_timeout=params.get('_request_timeout'),
3669                                        collection_formats=collection_formats)
3670
3671    def get_notification_defaults(self, account_id, **kwargs):
3672        """
3673        Returns default user level settings for a specified account
3674        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3675        This method makes a synchronous HTTP request by default. To make an
3676        asynchronous HTTP request, please define a `callback` function
3677        to be invoked when receiving the response.
3678        >>> def callback_function(response):
3679        >>>     pprint(response)
3680        >>>
3681        >>> thread = api.get_notification_defaults(account_id, callback=callback_function)
3682
3683        :param callback function: The callback function
3684            for asynchronous request. (optional)
3685        :param str account_id: The external account number (int) or account ID Guid. (required)
3686        :return: NotificationDefaults
3687                 If the method is called asynchronously,
3688                 returns the request thread.
3689        """
3690        kwargs['_return_http_data_only'] = True
3691        if kwargs.get('callback'):
3692            return self.get_notification_defaults_with_http_info(account_id, **kwargs)
3693        else:
3694            (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs)
3695            return data
3696
3697    def get_notification_defaults_with_http_info(self, account_id, **kwargs):
3698        """
3699        Returns default user level settings for a specified account
3700        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3701        This method makes a synchronous HTTP request by default. To make an
3702        asynchronous HTTP request, please define a `callback` function
3703        to be invoked when receiving the response.
3704        >>> def callback_function(response):
3705        >>>     pprint(response)
3706        >>>
3707        >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function)
3708
3709        :param callback function: The callback function
3710            for asynchronous request. (optional)
3711        :param str account_id: The external account number (int) or account ID Guid. (required)
3712        :return: NotificationDefaults
3713                 If the method is called asynchronously,
3714                 returns the request thread.
3715        """
3716
3717        all_params = ['account_id']
3718        all_params.append('callback')
3719        all_params.append('_return_http_data_only')
3720        all_params.append('_preload_content')
3721        all_params.append('_request_timeout')
3722
3723        params = locals()
3724        for key, val in iteritems(params['kwargs']):
3725            if key not in all_params:
3726                raise TypeError(
3727                    "Got an unexpected keyword argument '%s'"
3728                    " to method get_notification_defaults" % key
3729                )
3730            params[key] = val
3731        del params['kwargs']
3732        # verify the required parameter 'account_id' is set
3733        if ('account_id' not in params) or (params['account_id'] is None):
3734            raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`")
3735
3736
3737        collection_formats = {}
3738
3739        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
3740        path_params = {}
3741        if 'account_id' in params:
3742            path_params['accountId'] = params['account_id']
3743
3744        query_params = {}
3745
3746        header_params = {}
3747
3748        form_params = []
3749        local_var_files = {}
3750
3751        body_params = None
3752        # HTTP header `Accept`
3753        header_params['Accept'] = self.api_client.\
3754            select_header_accept(['application/json'])
3755
3756        # Authentication setting
3757        auth_settings = []
3758
3759        return self.api_client.call_api(resource_path, 'GET',
3760                                        path_params,
3761                                        query_params,
3762                                        header_params,
3763                                        body=body_params,
3764                                        post_params=form_params,
3765                                        files=local_var_files,
3766                                        response_type='NotificationDefaults',
3767                                        auth_settings=auth_settings,
3768                                        callback=params.get('callback'),
3769                                        _return_http_data_only=params.get('_return_http_data_only'),
3770                                        _preload_content=params.get('_preload_content', True),
3771                                        _request_timeout=params.get('_request_timeout'),
3772                                        collection_formats=collection_formats)
3773
3774    def get_password_rules(self, account_id, **kwargs):
3775        """
3776        Get the password rules
3777        This method retrieves the password rules for an account.
3778        This method makes a synchronous HTTP request by default. To make an
3779        asynchronous HTTP request, please define a `callback` function
3780        to be invoked when receiving the response.
3781        >>> def callback_function(response):
3782        >>>     pprint(response)
3783        >>>
3784        >>> thread = api.get_password_rules(account_id, callback=callback_function)
3785
3786        :param callback function: The callback function
3787            for asynchronous request. (optional)
3788        :param str account_id: The external account number (int) or account ID Guid. (required)
3789        :return: AccountPasswordRules
3790                 If the method is called asynchronously,
3791                 returns the request thread.
3792        """
3793        kwargs['_return_http_data_only'] = True
3794        if kwargs.get('callback'):
3795            return self.get_password_rules_with_http_info(account_id, **kwargs)
3796        else:
3797            (data) = self.get_password_rules_with_http_info(account_id, **kwargs)
3798            return data
3799
3800    def get_password_rules_with_http_info(self, account_id, **kwargs):
3801        """
3802        Get the password rules
3803        This method retrieves the password rules for an account.
3804        This method makes a synchronous HTTP request by default. To make an
3805        asynchronous HTTP request, please define a `callback` function
3806        to be invoked when receiving the response.
3807        >>> def callback_function(response):
3808        >>>     pprint(response)
3809        >>>
3810        >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function)
3811
3812        :param callback function: The callback function
3813            for asynchronous request. (optional)
3814        :param str account_id: The external account number (int) or account ID Guid. (required)
3815        :return: AccountPasswordRules
3816                 If the method is called asynchronously,
3817                 returns the request thread.
3818        """
3819
3820        all_params = ['account_id']
3821        all_params.append('callback')
3822        all_params.append('_return_http_data_only')
3823        all_params.append('_preload_content')
3824        all_params.append('_request_timeout')
3825
3826        params = locals()
3827        for key, val in iteritems(params['kwargs']):
3828            if key not in all_params:
3829                raise TypeError(
3830                    "Got an unexpected keyword argument '%s'"
3831                    " to method get_password_rules" % key
3832                )
3833            params[key] = val
3834        del params['kwargs']
3835        # verify the required parameter 'account_id' is set
3836        if ('account_id' not in params) or (params['account_id'] is None):
3837            raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`")
3838
3839
3840        collection_formats = {}
3841
3842        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
3843        path_params = {}
3844        if 'account_id' in params:
3845            path_params['accountId'] = params['account_id']
3846
3847        query_params = {}
3848
3849        header_params = {}
3850
3851        form_params = []
3852        local_var_files = {}
3853
3854        body_params = None
3855        # HTTP header `Accept`
3856        header_params['Accept'] = self.api_client.\
3857            select_header_accept(['application/json'])
3858
3859        # Authentication setting
3860        auth_settings = []
3861
3862        return self.api_client.call_api(resource_path, 'GET',
3863                                        path_params,
3864                                        query_params,
3865                                        header_params,
3866                                        body=body_params,
3867                                        post_params=form_params,
3868                                        files=local_var_files,
3869                                        response_type='AccountPasswordRules',
3870                                        auth_settings=auth_settings,
3871                                        callback=params.get('callback'),
3872                                        _return_http_data_only=params.get('_return_http_data_only'),
3873                                        _preload_content=params.get('_preload_content', True),
3874                                        _request_timeout=params.get('_request_timeout'),
3875                                        collection_formats=collection_formats)
3876
3877    def get_password_rules_0(self, **kwargs):
3878        """
3879        Get membership account password rules
3880        
3881        This method makes a synchronous HTTP request by default. To make an
3882        asynchronous HTTP request, please define a `callback` function
3883        to be invoked when receiving the response.
3884        >>> def callback_function(response):
3885        >>>     pprint(response)
3886        >>>
3887        >>> thread = api.get_password_rules_0(callback=callback_function)
3888
3889        :param callback function: The callback function
3890            for asynchronous request. (optional)
3891        :return: UserPasswordRules
3892                 If the method is called asynchronously,
3893                 returns the request thread.
3894        """
3895        kwargs['_return_http_data_only'] = True
3896        if kwargs.get('callback'):
3897            return self.get_password_rules_0_with_http_info(**kwargs)
3898        else:
3899            (data) = self.get_password_rules_0_with_http_info(**kwargs)
3900            return data
3901
3902    def get_password_rules_0_with_http_info(self, **kwargs):
3903        """
3904        Get membership account password rules
3905        
3906        This method makes a synchronous HTTP request by default. To make an
3907        asynchronous HTTP request, please define a `callback` function
3908        to be invoked when receiving the response.
3909        >>> def callback_function(response):
3910        >>>     pprint(response)
3911        >>>
3912        >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function)
3913
3914        :param callback function: The callback function
3915            for asynchronous request. (optional)
3916        :return: UserPasswordRules
3917                 If the method is called asynchronously,
3918                 returns the request thread.
3919        """
3920
3921        all_params = []
3922        all_params.append('callback')
3923        all_params.append('_return_http_data_only')
3924        all_params.append('_preload_content')
3925        all_params.append('_request_timeout')
3926
3927        params = locals()
3928        for key, val in iteritems(params['kwargs']):
3929            if key not in all_params:
3930                raise TypeError(
3931                    "Got an unexpected keyword argument '%s'"
3932                    " to method get_password_rules_0" % key
3933                )
3934            params[key] = val
3935        del params['kwargs']
3936
3937        collection_formats = {}
3938
3939        resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json')
3940        path_params = {}
3941
3942        query_params = {}
3943
3944        header_params = {}
3945
3946        form_params = []
3947        local_var_files = {}
3948
3949        body_params = None
3950        # HTTP header `Accept`
3951        header_params['Accept'] = self.api_client.\
3952            select_header_accept(['application/json'])
3953
3954        # Authentication setting
3955        auth_settings = []
3956
3957        return self.api_client.call_api(resource_path, 'GET',
3958                                        path_params,
3959                                        query_params,
3960                                        header_params,
3961                                        body=body_params,
3962                                        post_params=form_params,
3963                                        files=local_var_files,
3964                                        response_type='UserPasswordRules',
3965                                        auth_settings=auth_settings,
3966                                        callback=params.get('callback'),
3967                                        _return_http_data_only=params.get('_return_http_data_only'),
3968                                        _preload_content=params.get('_preload_content', True),
3969                                        _request_timeout=params.get('_request_timeout'),
3970                                        collection_formats=collection_formats)
3971
3972    def get_permission_profile(self, account_id, permission_profile_id, **kwargs):
3973        """
3974        Returns a permissions profile in the specified account.
3975        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
3976        This method makes a synchronous HTTP request by default. To make an
3977        asynchronous HTTP request, please define a `callback` function
3978        to be invoked when receiving the response.
3979        >>> def callback_function(response):
3980        >>>     pprint(response)
3981        >>>
3982        >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function)
3983
3984        :param callback function: The callback function
3985            for asynchronous request. (optional)
3986        :param str account_id: The external account number (int) or account ID Guid. (required)
3987        :param str permission_profile_id: (required)
3988        :param str include:
3989        :return: PermissionProfile
3990                 If the method is called asynchronously,
3991                 returns the request thread.
3992        """
3993        kwargs['_return_http_data_only'] = True
3994        if kwargs.get('callback'):
3995            return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3996        else:
3997            (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3998            return data
3999
4000    def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
4001        """
4002        Returns a permissions profile in the specified account.
4003        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
4004        This method makes a synchronous HTTP request by default. To make an
4005        asynchronous HTTP request, please define a `callback` function
4006        to be invoked when receiving the response.
4007        >>> def callback_function(response):
4008        >>>     pprint(response)
4009        >>>
4010        >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
4011
4012        :param callback function: The callback function
4013            for asynchronous request. (optional)
4014        :param str account_id: The external account number (int) or account ID Guid. (required)
4015        :param str permission_profile_id: (required)
4016        :param str include:
4017        :return: PermissionProfile
4018                 If the method is called asynchronously,
4019                 returns the request thread.
4020        """
4021
4022        all_params = ['account_id', 'permission_profile_id', 'include']
4023        all_params.append('callback')
4024        all_params.append('_return_http_data_only')
4025        all_params.append('_preload_content')
4026        all_params.append('_request_timeout')
4027
4028        params = locals()
4029        for key, val in iteritems(params['kwargs']):
4030            if key not in all_params:
4031                raise TypeError(
4032                    "Got an unexpected keyword argument '%s'"
4033                    " to method get_permission_profile" % key
4034                )
4035            params[key] = val
4036        del params['kwargs']
4037        # verify the required parameter 'account_id' is set
4038        if ('account_id' not in params) or (params['account_id'] is None):
4039            raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`")
4040        # verify the required parameter 'permission_profile_id' is set
4041        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
4042            raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`")
4043
4044
4045        collection_formats = {}
4046
4047        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
4048        path_params = {}
4049        if 'account_id' in params:
4050            path_params['accountId'] = params['account_id']
4051        if 'permission_profile_id' in params:
4052            path_params['permissionProfileId'] = params['permission_profile_id']
4053
4054        query_params = {}
4055        if 'include' in params:
4056            query_params['include'] = params['include']
4057
4058        header_params = {}
4059
4060        form_params = []
4061        local_var_files = {}
4062
4063        body_params = None
4064        # HTTP header `Accept`
4065        header_params['Accept'] = self.api_client.\
4066            select_header_accept(['application/json'])
4067
4068        # Authentication setting
4069        auth_settings = []
4070
4071        return self.api_client.call_api(resource_path, 'GET',
4072                                        path_params,
4073                                        query_params,
4074                                        header_params,
4075                                        body=body_params,
4076                                        post_params=form_params,
4077                                        files=local_var_files,
4078                                        response_type='PermissionProfile',
4079                                        auth_settings=auth_settings,
4080                                        callback=params.get('callback'),
4081                                        _return_http_data_only=params.get('_return_http_data_only'),
4082                                        _preload_content=params.get('_preload_content', True),
4083                                        _request_timeout=params.get('_request_timeout'),
4084                                        collection_formats=collection_formats)
4085
4086    def get_provisioning(self, **kwargs):
4087        """
4088        Retrieves the account provisioning information for the account.
4089        Retrieves the account provisioning information for the account.
4090        This method makes a synchronous HTTP request by default. To make an
4091        asynchronous HTTP request, please define a `callback` function
4092        to be invoked when receiving the response.
4093        >>> def callback_function(response):
4094        >>>     pprint(response)
4095        >>>
4096        >>> thread = api.get_provisioning(callback=callback_function)
4097
4098        :param callback function: The callback function
4099            for asynchronous request. (optional)
4100        :return: ProvisioningInformation
4101                 If the method is called asynchronously,
4102                 returns the request thread.
4103        """
4104        kwargs['_return_http_data_only'] = True
4105        if kwargs.get('callback'):
4106            return self.get_provisioning_with_http_info(**kwargs)
4107        else:
4108            (data) = self.get_provisioning_with_http_info(**kwargs)
4109            return data
4110
4111    def get_provisioning_with_http_info(self, **kwargs):
4112        """
4113        Retrieves the account provisioning information for the account.
4114        Retrieves the account provisioning information for the account.
4115        This method makes a synchronous HTTP request by default. To make an
4116        asynchronous HTTP request, please define a `callback` function
4117        to be invoked when receiving the response.
4118        >>> def callback_function(response):
4119        >>>     pprint(response)
4120        >>>
4121        >>> thread = api.get_provisioning_with_http_info(callback=callback_function)
4122
4123        :param callback function: The callback function
4124            for asynchronous request. (optional)
4125        :return: ProvisioningInformation
4126                 If the method is called asynchronously,
4127                 returns the request thread.
4128        """
4129
4130        all_params = []
4131        all_params.append('callback')
4132        all_params.append('_return_http_data_only')
4133        all_params.append('_preload_content')
4134        all_params.append('_request_timeout')
4135
4136        params = locals()
4137        for key, val in iteritems(params['kwargs']):
4138            if key not in all_params:
4139                raise TypeError(
4140                    "Got an unexpected keyword argument '%s'"
4141                    " to method get_provisioning" % key
4142                )
4143            params[key] = val
4144        del params['kwargs']
4145
4146        collection_formats = {}
4147
4148        resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json')
4149        path_params = {}
4150
4151        query_params = {}
4152
4153        header_params = {}
4154
4155        form_params = []
4156        local_var_files = {}
4157
4158        body_params = None
4159        # HTTP header `Accept`
4160        header_params['Accept'] = self.api_client.\
4161            select_header_accept(['application/json'])
4162
4163        # Authentication setting
4164        auth_settings = []
4165
4166        return self.api_client.call_api(resource_path, 'GET',
4167                                        path_params,
4168                                        query_params,
4169                                        header_params,
4170                                        body=body_params,
4171                                        post_params=form_params,
4172                                        files=local_var_files,
4173                                        response_type='ProvisioningInformation',
4174                                        auth_settings=auth_settings,
4175                                        callback=params.get('callback'),
4176                                        _return_http_data_only=params.get('_return_http_data_only'),
4177                                        _preload_content=params.get('_preload_content', True),
4178                                        _request_timeout=params.get('_request_timeout'),
4179                                        collection_formats=collection_formats)
4180
4181    def get_supported_languages(self, account_id, **kwargs):
4182        """
4183        Gets list of supported languages for recipient language setting.
4184        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4185        This method makes a synchronous HTTP request by default. To make an
4186        asynchronous HTTP request, please define a `callback` function
4187        to be invoked when receiving the response.
4188        >>> def callback_function(response):
4189        >>>     pprint(response)
4190        >>>
4191        >>> thread = api.get_supported_languages(account_id, callback=callback_function)
4192
4193        :param callback function: The callback function
4194            for asynchronous request. (optional)
4195        :param str account_id: The external account number (int) or account ID Guid. (required)
4196        :return: SupportedLanguages
4197                 If the method is called asynchronously,
4198                 returns the request thread.
4199        """
4200        kwargs['_return_http_data_only'] = True
4201        if kwargs.get('callback'):
4202            return self.get_supported_languages_with_http_info(account_id, **kwargs)
4203        else:
4204            (data) = self.get_supported_languages_with_http_info(account_id, **kwargs)
4205            return data
4206
4207    def get_supported_languages_with_http_info(self, account_id, **kwargs):
4208        """
4209        Gets list of supported languages for recipient language setting.
4210        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4211        This method makes a synchronous HTTP request by default. To make an
4212        asynchronous HTTP request, please define a `callback` function
4213        to be invoked when receiving the response.
4214        >>> def callback_function(response):
4215        >>>     pprint(response)
4216        >>>
4217        >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function)
4218
4219        :param callback function: The callback function
4220            for asynchronous request. (optional)
4221        :param str account_id: The external account number (int) or account ID Guid. (required)
4222        :return: SupportedLanguages
4223                 If the method is called asynchronously,
4224                 returns the request thread.
4225        """
4226
4227        all_params = ['account_id']
4228        all_params.append('callback')
4229        all_params.append('_return_http_data_only')
4230        all_params.append('_preload_content')
4231        all_params.append('_request_timeout')
4232
4233        params = locals()
4234        for key, val in iteritems(params['kwargs']):
4235            if key not in all_params:
4236                raise TypeError(
4237                    "Got an unexpected keyword argument '%s'"
4238                    " to method get_supported_languages" % key
4239                )
4240            params[key] = val
4241        del params['kwargs']
4242        # verify the required parameter 'account_id' is set
4243        if ('account_id' not in params) or (params['account_id'] is None):
4244            raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`")
4245
4246
4247        collection_formats = {}
4248
4249        resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json')
4250        path_params = {}
4251        if 'account_id' in params:
4252            path_params['accountId'] = params['account_id']
4253
4254        query_params = {}
4255
4256        header_params = {}
4257
4258        form_params = []
4259        local_var_files = {}
4260
4261        body_params = None
4262        # HTTP header `Accept`
4263        header_params['Accept'] = self.api_client.\
4264            select_header_accept(['application/json'])
4265
4266        # Authentication setting
4267        auth_settings = []
4268
4269        return self.api_client.call_api(resource_path, 'GET',
4270                                        path_params,
4271                                        query_params,
4272                                        header_params,
4273                                        body=body_params,
4274                                        post_params=form_params,
4275                                        files=local_var_files,
4276                                        response_type='SupportedLanguages',
4277                                        auth_settings=auth_settings,
4278                                        callback=params.get('callback'),
4279                                        _return_http_data_only=params.get('_return_http_data_only'),
4280                                        _preload_content=params.get('_preload_content', True),
4281                                        _request_timeout=params.get('_request_timeout'),
4282                                        collection_formats=collection_formats)
4283
4284    def get_watermark(self, account_id, **kwargs):
4285        """
4286        Get watermark information.
4287        
4288        This method makes a synchronous HTTP request by default. To make an
4289        asynchronous HTTP request, please define a `callback` function
4290        to be invoked when receiving the response.
4291        >>> def callback_function(response):
4292        >>>     pprint(response)
4293        >>>
4294        >>> thread = api.get_watermark(account_id, callback=callback_function)
4295
4296        :param callback function: The callback function
4297            for asynchronous request. (optional)
4298        :param str account_id: The external account number (int) or account ID Guid. (required)
4299        :return: Watermark
4300                 If the method is called asynchronously,
4301                 returns the request thread.
4302        """
4303        kwargs['_return_http_data_only'] = True
4304        if kwargs.get('callback'):
4305            return self.get_watermark_with_http_info(account_id, **kwargs)
4306        else:
4307            (data) = self.get_watermark_with_http_info(account_id, **kwargs)
4308            return data
4309
4310    def get_watermark_with_http_info(self, account_id, **kwargs):
4311        """
4312        Get watermark information.
4313        
4314        This method makes a synchronous HTTP request by default. To make an
4315        asynchronous HTTP request, please define a `callback` function
4316        to be invoked when receiving the response.
4317        >>> def callback_function(response):
4318        >>>     pprint(response)
4319        >>>
4320        >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function)
4321
4322        :param callback function: The callback function
4323            for asynchronous request. (optional)
4324        :param str account_id: The external account number (int) or account ID Guid. (required)
4325        :return: Watermark
4326                 If the method is called asynchronously,
4327                 returns the request thread.
4328        """
4329
4330        all_params = ['account_id']
4331        all_params.append('callback')
4332        all_params.append('_return_http_data_only')
4333        all_params.append('_preload_content')
4334        all_params.append('_request_timeout')
4335
4336        params = locals()
4337        for key, val in iteritems(params['kwargs']):
4338            if key not in all_params:
4339                raise TypeError(
4340                    "Got an unexpected keyword argument '%s'"
4341                    " to method get_watermark" % key
4342                )
4343            params[key] = val
4344        del params['kwargs']
4345        # verify the required parameter 'account_id' is set
4346        if ('account_id' not in params) or (params['account_id'] is None):
4347            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`")
4348
4349
4350        collection_formats = {}
4351
4352        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
4353        path_params = {}
4354        if 'account_id' in params:
4355            path_params['accountId'] = params['account_id']
4356
4357        query_params = {}
4358
4359        header_params = {}
4360
4361        form_params = []
4362        local_var_files = {}
4363
4364        body_params = None
4365        # HTTP header `Accept`
4366        header_params['Accept'] = self.api_client.\
4367            select_header_accept(['application/json'])
4368
4369        # Authentication setting
4370        auth_settings = []
4371
4372        return self.api_client.call_api(resource_path, 'GET',
4373                                        path_params,
4374                                        query_params,
4375                                        header_params,
4376                                        body=body_params,
4377                                        post_params=form_params,
4378                                        files=local_var_files,
4379                                        response_type='Watermark',
4380                                        auth_settings=auth_settings,
4381                                        callback=params.get('callback'),
4382                                        _return_http_data_only=params.get('_return_http_data_only'),
4383                                        _preload_content=params.get('_preload_content', True),
4384                                        _request_timeout=params.get('_request_timeout'),
4385                                        collection_formats=collection_formats)
4386
4387    def get_watermark_preview(self, account_id, **kwargs):
4388        """
4389        Get watermark preview.
4390        
4391        This method makes a synchronous HTTP request by default. To make an
4392        asynchronous HTTP request, please define a `callback` function
4393        to be invoked when receiving the response.
4394        >>> def callback_function(response):
4395        >>>     pprint(response)
4396        >>>
4397        >>> thread = api.get_watermark_preview(account_id, callback=callback_function)
4398
4399        :param callback function: The callback function
4400            for asynchronous request. (optional)
4401        :param str account_id: The external account number (int) or account ID Guid. (required)
4402        :param Watermark watermark:
4403        :return: Watermark
4404                 If the method is called asynchronously,
4405                 returns the request thread.
4406        """
4407        kwargs['_return_http_data_only'] = True
4408        if kwargs.get('callback'):
4409            return self.get_watermark_preview_with_http_info(account_id, **kwargs)
4410        else:
4411            (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs)
4412            return data
4413
4414    def get_watermark_preview_with_http_info(self, account_id, **kwargs):
4415        """
4416        Get watermark preview.
4417        
4418        This method makes a synchronous HTTP request by default. To make an
4419        asynchronous HTTP request, please define a `callback` function
4420        to be invoked when receiving the response.
4421        >>> def callback_function(response):
4422        >>>     pprint(response)
4423        >>>
4424        >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function)
4425
4426        :param callback function: The callback function
4427            for asynchronous request. (optional)
4428        :param str account_id: The external account number (int) or account ID Guid. (required)
4429        :param Watermark watermark:
4430        :return: Watermark
4431                 If the method is called asynchronously,
4432                 returns the request thread.
4433        """
4434
4435        all_params = ['account_id', 'watermark']
4436        all_params.append('callback')
4437        all_params.append('_return_http_data_only')
4438        all_params.append('_preload_content')
4439        all_params.append('_request_timeout')
4440
4441        params = locals()
4442        for key, val in iteritems(params['kwargs']):
4443            if key not in all_params:
4444                raise TypeError(
4445                    "Got an unexpected keyword argument '%s'"
4446                    " to method get_watermark_preview" % key
4447                )
4448            params[key] = val
4449        del params['kwargs']
4450        # verify the required parameter 'account_id' is set
4451        if ('account_id' not in params) or (params['account_id'] is None):
4452            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`")
4453
4454
4455        collection_formats = {}
4456
4457        resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json')
4458        path_params = {}
4459        if 'account_id' in params:
4460            path_params['accountId'] = params['account_id']
4461
4462        query_params = {}
4463
4464        header_params = {}
4465
4466        form_params = []
4467        local_var_files = {}
4468
4469        body_params = None
4470        if 'watermark' in params:
4471            body_params = params['watermark']
4472        # HTTP header `Accept`
4473        header_params['Accept'] = self.api_client.\
4474            select_header_accept(['application/json'])
4475
4476        # Authentication setting
4477        auth_settings = []
4478
4479        return self.api_client.call_api(resource_path, 'PUT',
4480                                        path_params,
4481                                        query_params,
4482                                        header_params,
4483                                        body=body_params,
4484                                        post_params=form_params,
4485                                        files=local_var_files,
4486                                        response_type='Watermark',
4487                                        auth_settings=auth_settings,
4488                                        callback=params.get('callback'),
4489                                        _return_http_data_only=params.get('_return_http_data_only'),
4490                                        _preload_content=params.get('_preload_content', True),
4491                                        _request_timeout=params.get('_request_timeout'),
4492                                        collection_formats=collection_formats)
4493
4494    def list_brands(self, account_id, **kwargs):
4495        """
4496        Gets a list of brand profiles.
4497        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4498        This method makes a synchronous HTTP request by default. To make an
4499        asynchronous HTTP request, please define a `callback` function
4500        to be invoked when receiving the response.
4501        >>> def callback_function(response):
4502        >>>     pprint(response)
4503        >>>
4504        >>> thread = api.list_brands(account_id, callback=callback_function)
4505
4506        :param callback function: The callback function
4507            for asynchronous request. (optional)
4508        :param str account_id: The external account number (int) or account ID Guid. (required)
4509        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4510        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4511        :return: BrandsResponse
4512                 If the method is called asynchronously,
4513                 returns the request thread.
4514        """
4515        kwargs['_return_http_data_only'] = True
4516        if kwargs.get('callback'):
4517            return self.list_brands_with_http_info(account_id, **kwargs)
4518        else:
4519            (data) = self.list_brands_with_http_info(account_id, **kwargs)
4520            return data
4521
4522    def list_brands_with_http_info(self, account_id, **kwargs):
4523        """
4524        Gets a list of brand profiles.
4525        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4526        This method makes a synchronous HTTP request by default. To make an
4527        asynchronous HTTP request, please define a `callback` function
4528        to be invoked when receiving the response.
4529        >>> def callback_function(response):
4530        >>>     pprint(response)
4531        >>>
4532        >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function)
4533
4534        :param callback function: The callback function
4535            for asynchronous request. (optional)
4536        :param str account_id: The external account number (int) or account ID Guid. (required)
4537        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4538        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4539        :return: BrandsResponse
4540                 If the method is called asynchronously,
4541                 returns the request thread.
4542        """
4543
4544        all_params = ['account_id', 'exclude_distributor_brand', 'include_logos']
4545        all_params.append('callback')
4546        all_params.append('_return_http_data_only')
4547        all_params.append('_preload_content')
4548        all_params.append('_request_timeout')
4549
4550        params = locals()
4551        for key, val in iteritems(params['kwargs']):
4552            if key not in all_params:
4553                raise TypeError(
4554                    "Got an unexpected keyword argument '%s'"
4555                    " to method list_brands" % key
4556                )
4557            params[key] = val
4558        del params['kwargs']
4559        # verify the required parameter 'account_id' is set
4560        if ('account_id' not in params) or (params['account_id'] is None):
4561            raise ValueError("Missing the required parameter `account_id` when calling `list_brands`")
4562
4563
4564        collection_formats = {}
4565
4566        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
4567        path_params = {}
4568        if 'account_id' in params:
4569            path_params['accountId'] = params['account_id']
4570
4571        query_params = {}
4572        if 'exclude_distributor_brand' in params:
4573            query_params['exclude_distributor_brand'] = params['exclude_distributor_brand']
4574        if 'include_logos' in params:
4575            query_params['include_logos'] = params['include_logos']
4576
4577        header_params = {}
4578
4579        form_params = []
4580        local_var_files = {}
4581
4582        body_params = None
4583        # HTTP header `Accept`
4584        header_params['Accept'] = self.api_client.\
4585            select_header_accept(['application/json'])
4586
4587        # Authentication setting
4588        auth_settings = []
4589
4590        return self.api_client.call_api(resource_path, 'GET',
4591                                        path_params,
4592                                        query_params,
4593                                        header_params,
4594                                        body=body_params,
4595                                        post_params=form_params,
4596                                        files=local_var_files,
4597                                        response_type='BrandsResponse',
4598                                        auth_settings=auth_settings,
4599                                        callback=params.get('callback'),
4600                                        _return_http_data_only=params.get('_return_http_data_only'),
4601                                        _preload_content=params.get('_preload_content', True),
4602                                        _request_timeout=params.get('_request_timeout'),
4603                                        collection_formats=collection_formats)
4604
4605    def list_custom_fields(self, account_id, **kwargs):
4606        """
4607        Gets a list of custom fields associated with the account.
4608        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4609        This method makes a synchronous HTTP request by default. To make an
4610        asynchronous HTTP request, please define a `callback` function
4611        to be invoked when receiving the response.
4612        >>> def callback_function(response):
4613        >>>     pprint(response)
4614        >>>
4615        >>> thread = api.list_custom_fields(account_id, callback=callback_function)
4616
4617        :param callback function: The callback function
4618            for asynchronous request. (optional)
4619        :param str account_id: The external account number (int) or account ID Guid. (required)
4620        :return: CustomFields
4621                 If the method is called asynchronously,
4622                 returns the request thread.
4623        """
4624        kwargs['_return_http_data_only'] = True
4625        if kwargs.get('callback'):
4626            return self.list_custom_fields_with_http_info(account_id, **kwargs)
4627        else:
4628            (data) = self.list_custom_fields_with_http_info(account_id, **kwargs)
4629            return data
4630
4631    def list_custom_fields_with_http_info(self, account_id, **kwargs):
4632        """
4633        Gets a list of custom fields associated with the account.
4634        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4635        This method makes a synchronous HTTP request by default. To make an
4636        asynchronous HTTP request, please define a `callback` function
4637        to be invoked when receiving the response.
4638        >>> def callback_function(response):
4639        >>>     pprint(response)
4640        >>>
4641        >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function)
4642
4643        :param callback function: The callback function
4644            for asynchronous request. (optional)
4645        :param str account_id: The external account number (int) or account ID Guid. (required)
4646        :return: CustomFields
4647                 If the method is called asynchronously,
4648                 returns the request thread.
4649        """
4650
4651        all_params = ['account_id']
4652        all_params.append('callback')
4653        all_params.append('_return_http_data_only')
4654        all_params.append('_preload_content')
4655        all_params.append('_request_timeout')
4656
4657        params = locals()
4658        for key, val in iteritems(params['kwargs']):
4659            if key not in all_params:
4660                raise TypeError(
4661                    "Got an unexpected keyword argument '%s'"
4662                    " to method list_custom_fields" % key
4663                )
4664            params[key] = val
4665        del params['kwargs']
4666        # verify the required parameter 'account_id' is set
4667        if ('account_id' not in params) or (params['account_id'] is None):
4668            raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`")
4669
4670
4671        collection_formats = {}
4672
4673        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
4674        path_params = {}
4675        if 'account_id' in params:
4676            path_params['accountId'] = params['account_id']
4677
4678        query_params = {}
4679
4680        header_params = {}
4681
4682        form_params = []
4683        local_var_files = {}
4684
4685        body_params = None
4686        # HTTP header `Accept`
4687        header_params['Accept'] = self.api_client.\
4688            select_header_accept(['application/json'])
4689
4690        # Authentication setting
4691        auth_settings = []
4692
4693        return self.api_client.call_api(resource_path, 'GET',
4694                                        path_params,
4695                                        query_params,
4696                                        header_params,
4697                                        body=body_params,
4698                                        post_params=form_params,
4699                                        files=local_var_files,
4700                                        response_type='CustomFields',
4701                                        auth_settings=auth_settings,
4702                                        callback=params.get('callback'),
4703                                        _return_http_data_only=params.get('_return_http_data_only'),
4704                                        _preload_content=params.get('_preload_content', True),
4705                                        _request_timeout=params.get('_request_timeout'),
4706                                        collection_formats=collection_formats)
4707
4708    def list_permissions(self, account_id, **kwargs):
4709        """
4710        Gets a list of permission profiles.
4711        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4712        This method makes a synchronous HTTP request by default. To make an
4713        asynchronous HTTP request, please define a `callback` function
4714        to be invoked when receiving the response.
4715        >>> def callback_function(response):
4716        >>>     pprint(response)
4717        >>>
4718        >>> thread = api.list_permissions(account_id, callback=callback_function)
4719
4720        :param callback function: The callback function
4721            for asynchronous request. (optional)
4722        :param str account_id: The external account number (int) or account ID Guid. (required)
4723        :param str include:
4724        :return: PermissionProfileInformation
4725                 If the method is called asynchronously,
4726                 returns the request thread.
4727        """
4728        kwargs['_return_http_data_only'] = True
4729        if kwargs.get('callback'):
4730            return self.list_permissions_with_http_info(account_id, **kwargs)
4731        else:
4732            (data) = self.list_permissions_with_http_info(account_id, **kwargs)
4733            return data
4734
4735    def list_permissions_with_http_info(self, account_id, **kwargs):
4736        """
4737        Gets a list of permission profiles.
4738        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4739        This method makes a synchronous HTTP request by default. To make an
4740        asynchronous HTTP request, please define a `callback` function
4741        to be invoked when receiving the response.
4742        >>> def callback_function(response):
4743        >>>     pprint(response)
4744        >>>
4745        >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
4746
4747        :param callback function: The callback function
4748            for asynchronous request. (optional)
4749        :param str account_id: The external account number (int) or account ID Guid. (required)
4750        :param str include:
4751        :return: PermissionProfileInformation
4752                 If the method is called asynchronously,
4753                 returns the request thread.
4754        """
4755
4756        all_params = ['account_id', 'include']
4757        all_params.append('callback')
4758        all_params.append('_return_http_data_only')
4759        all_params.append('_preload_content')
4760        all_params.append('_request_timeout')
4761
4762        params = locals()
4763        for key, val in iteritems(params['kwargs']):
4764            if key not in all_params:
4765                raise TypeError(
4766                    "Got an unexpected keyword argument '%s'"
4767                    " to method list_permissions" % key
4768                )
4769            params[key] = val
4770        del params['kwargs']
4771        # verify the required parameter 'account_id' is set
4772        if ('account_id' not in params) or (params['account_id'] is None):
4773            raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`")
4774
4775
4776        collection_formats = {}
4777
4778        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
4779        path_params = {}
4780        if 'account_id' in params:
4781            path_params['accountId'] = params['account_id']
4782
4783        query_params = {}
4784        if 'include' in params:
4785            query_params['include'] = params['include']
4786
4787        header_params = {}
4788
4789        form_params = []
4790        local_var_files = {}
4791
4792        body_params = None
4793        # HTTP header `Accept`
4794        header_params['Accept'] = self.api_client.\
4795            select_header_accept(['application/json'])
4796
4797        # Authentication setting
4798        auth_settings = []
4799
4800        return self.api_client.call_api(resource_path, 'GET',
4801                                        path_params,
4802                                        query_params,
4803                                        header_params,
4804                                        body=body_params,
4805                                        post_params=form_params,
4806                                        files=local_var_files,
4807                                        response_type='PermissionProfileInformation',
4808                                        auth_settings=auth_settings,
4809                                        callback=params.get('callback'),
4810                                        _return_http_data_only=params.get('_return_http_data_only'),
4811                                        _preload_content=params.get('_preload_content', True),
4812                                        _request_timeout=params.get('_request_timeout'),
4813                                        collection_formats=collection_formats)
4814
4815    def list_recipient_names_by_email(self, account_id, **kwargs):
4816        """
4817        Gets recipient names associated with an email address.
4818        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4819        This method makes a synchronous HTTP request by default. To make an
4820        asynchronous HTTP request, please define a `callback` function
4821        to be invoked when receiving the response.
4822        >>> def callback_function(response):
4823        >>>     pprint(response)
4824        >>>
4825        >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
4826
4827        :param callback function: The callback function
4828            for asynchronous request. (optional)
4829        :param str account_id: The external account number (int) or account ID Guid. (required)
4830        :param str email: The email address for the user
4831        :return: RecipientNamesResponse
4832                 If the method is called asynchronously,
4833                 returns the request thread.
4834        """
4835        kwargs['_return_http_data_only'] = True
4836        if kwargs.get('callback'):
4837            return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4838        else:
4839            (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4840            return data
4841
4842    def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs):
4843        """
4844        Gets recipient names associated with an email address.
4845        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4846        This method makes a synchronous HTTP request by default. To make an
4847        asynchronous HTTP request, please define a `callback` function
4848        to be invoked when receiving the response.
4849        >>> def callback_function(response):
4850        >>>     pprint(response)
4851        >>>
4852        >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
4853
4854        :param callback function: The callback function
4855            for asynchronous request. (optional)
4856        :param str account_id: The external account number (int) or account ID Guid. (required)
4857        :param str email: The email address for the user
4858        :return: RecipientNamesResponse
4859                 If the method is called asynchronously,
4860                 returns the request thread.
4861        """
4862
4863        all_params = ['account_id', 'email']
4864        all_params.append('callback')
4865        all_params.append('_return_http_data_only')
4866        all_params.append('_preload_content')
4867        all_params.append('_request_timeout')
4868
4869        params = locals()
4870        for key, val in iteritems(params['kwargs']):
4871            if key not in all_params:
4872                raise TypeError(
4873                    "Got an unexpected keyword argument '%s'"
4874                    " to method list_recipient_names_by_email" % key
4875                )
4876            params[key] = val
4877        del params['kwargs']
4878        # verify the required parameter 'account_id' is set
4879        if ('account_id' not in params) or (params['account_id'] is None):
4880            raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`")
4881
4882
4883        collection_formats = {}
4884
4885        resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json')
4886        path_params = {}
4887        if 'account_id' in params:
4888            path_params['accountId'] = params['account_id']
4889
4890        query_params = {}
4891        if 'email' in params:
4892            query_params['email'] = params['email']
4893
4894        header_params = {}
4895
4896        form_params = []
4897        local_var_files = {}
4898
4899        body_params = None
4900        # HTTP header `Accept`
4901        header_params['Accept'] = self.api_client.\
4902            select_header_accept(['application/json'])
4903
4904        # Authentication setting
4905        auth_settings = []
4906
4907        return self.api_client.call_api(resource_path, 'GET',
4908                                        path_params,
4909                                        query_params,
4910                                        header_params,
4911                                        body=body_params,
4912                                        post_params=form_params,
4913                                        files=local_var_files,
4914                                        response_type='RecipientNamesResponse',
4915                                        auth_settings=auth_settings,
4916                                        callback=params.get('callback'),
4917                                        _return_http_data_only=params.get('_return_http_data_only'),
4918                                        _preload_content=params.get('_preload_content', True),
4919                                        _request_timeout=params.get('_request_timeout'),
4920                                        collection_formats=collection_formats)
4921
4922    def list_settings(self, account_id, **kwargs):
4923        """
4924        Gets account settings information.
4925        Retrieves the account settings information for the specified account.
4926        This method makes a synchronous HTTP request by default. To make an
4927        asynchronous HTTP request, please define a `callback` function
4928        to be invoked when receiving the response.
4929        >>> def callback_function(response):
4930        >>>     pprint(response)
4931        >>>
4932        >>> thread = api.list_settings(account_id, callback=callback_function)
4933
4934        :param callback function: The callback function
4935            for asynchronous request. (optional)
4936        :param str account_id: The external account number (int) or account ID Guid. (required)
4937        :return: AccountSettingsInformation
4938                 If the method is called asynchronously,
4939                 returns the request thread.
4940        """
4941        kwargs['_return_http_data_only'] = True
4942        if kwargs.get('callback'):
4943            return self.list_settings_with_http_info(account_id, **kwargs)
4944        else:
4945            (data) = self.list_settings_with_http_info(account_id, **kwargs)
4946            return data
4947
4948    def list_settings_with_http_info(self, account_id, **kwargs):
4949        """
4950        Gets account settings information.
4951        Retrieves the account settings information for the specified account.
4952        This method makes a synchronous HTTP request by default. To make an
4953        asynchronous HTTP request, please define a `callback` function
4954        to be invoked when receiving the response.
4955        >>> def callback_function(response):
4956        >>>     pprint(response)
4957        >>>
4958        >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function)
4959
4960        :param callback function: The callback function
4961            for asynchronous request. (optional)
4962        :param str account_id: The external account number (int) or account ID Guid. (required)
4963        :return: AccountSettingsInformation
4964                 If the method is called asynchronously,
4965                 returns the request thread.
4966        """
4967
4968        all_params = ['account_id']
4969        all_params.append('callback')
4970        all_params.append('_return_http_data_only')
4971        all_params.append('_preload_content')
4972        all_params.append('_request_timeout')
4973
4974        params = locals()
4975        for key, val in iteritems(params['kwargs']):
4976            if key not in all_params:
4977                raise TypeError(
4978                    "Got an unexpected keyword argument '%s'"
4979                    " to method list_settings" % key
4980                )
4981            params[key] = val
4982        del params['kwargs']
4983        # verify the required parameter 'account_id' is set
4984        if ('account_id' not in params) or (params['account_id'] is None):
4985            raise ValueError("Missing the required parameter `account_id` when calling `list_settings`")
4986
4987
4988        collection_formats = {}
4989
4990        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
4991        path_params = {}
4992        if 'account_id' in params:
4993            path_params['accountId'] = params['account_id']
4994
4995        query_params = {}
4996
4997        header_params = {}
4998
4999        form_params = []
5000        local_var_files = {}
5001
5002        body_params = None
5003        # HTTP header `Accept`
5004        header_params['Accept'] = self.api_client.\
5005            select_header_accept(['application/json'])
5006
5007        # Authentication setting
5008        auth_settings = []
5009
5010        return self.api_client.call_api(resource_path, 'GET',
5011                                        path_params,
5012                                        query_params,
5013                                        header_params,
5014                                        body=body_params,
5015                                        post_params=form_params,
5016                                        files=local_var_files,
5017                                        response_type='AccountSettingsInformation',
5018                                        auth_settings=auth_settings,
5019                                        callback=params.get('callback'),
5020                                        _return_http_data_only=params.get('_return_http_data_only'),
5021                                        _preload_content=params.get('_preload_content', True),
5022                                        _request_timeout=params.get('_request_timeout'),
5023                                        collection_formats=collection_formats)
5024
5025    def list_shared_access(self, account_id, **kwargs):
5026        """
5027        Reserved: Gets the shared item status for one or more users.
5028        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5029        This method makes a synchronous HTTP request by default. To make an
5030        asynchronous HTTP request, please define a `callback` function
5031        to be invoked when receiving the response.
5032        >>> def callback_function(response):
5033        >>>     pprint(response)
5034        >>>
5035        >>> thread = api.list_shared_access(account_id, callback=callback_function)
5036
5037        :param callback function: The callback function
5038            for asynchronous request. (optional)
5039        :param str account_id: The external account number (int) or account ID Guid. (required)
5040        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5041        :param str envelopes_not_shared_user_status:
5042        :param str folder_ids:
5043        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5044        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5045        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5046        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5047        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5048        :return: AccountSharedAccess
5049                 If the method is called asynchronously,
5050                 returns the request thread.
5051        """
5052        kwargs['_return_http_data_only'] = True
5053        if kwargs.get('callback'):
5054            return self.list_shared_access_with_http_info(account_id, **kwargs)
5055        else:
5056            (data) = self.list_shared_access_with_http_info(account_id, **kwargs)
5057            return data
5058
5059    def list_shared_access_with_http_info(self, account_id, **kwargs):
5060        """
5061        Reserved: Gets the shared item status for one or more users.
5062        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5063        This method makes a synchronous HTTP request by default. To make an
5064        asynchronous HTTP request, please define a `callback` function
5065        to be invoked when receiving the response.
5066        >>> def callback_function(response):
5067        >>>     pprint(response)
5068        >>>
5069        >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function)
5070
5071        :param callback function: The callback function
5072            for asynchronous request. (optional)
5073        :param str account_id: The external account number (int) or account ID Guid. (required)
5074        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5075        :param str envelopes_not_shared_user_status:
5076        :param str folder_ids:
5077        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5078        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5079        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5080        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5081        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5082        :return: AccountSharedAccess
5083                 If the method is called asynchronously,
5084                 returns the request thread.
5085        """
5086
5087        all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids']
5088        all_params.append('callback')
5089        all_params.append('_return_http_data_only')
5090        all_params.append('_preload_content')
5091        all_params.append('_request_timeout')
5092
5093        params = locals()
5094        for key, val in iteritems(params['kwargs']):
5095            if key not in all_params:
5096                raise TypeError(
5097                    "Got an unexpected keyword argument '%s'"
5098                    " to method list_shared_access" % key
5099                )
5100            params[key] = val
5101        del params['kwargs']
5102        # verify the required parameter 'account_id' is set
5103        if ('account_id' not in params) or (params['account_id'] is None):
5104            raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`")
5105
5106
5107        collection_formats = {}
5108
5109        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
5110        path_params = {}
5111        if 'account_id' in params:
5112            path_params['accountId'] = params['account_id']
5113
5114        query_params = {}
5115        if 'count' in params:
5116            query_params['count'] = params['count']
5117        if 'envelopes_not_shared_user_status' in params:
5118            query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status']
5119        if 'folder_ids' in params:
5120            query_params['folder_ids'] = params['folder_ids']
5121        if 'item_type' in params:
5122            query_params['item_type'] = params['item_type']
5123        if 'search_text' in params:
5124            query_params['search_text'] = params['search_text']
5125        if 'shared' in params:
5126            query_params['shared'] = params['shared']
5127        if 'start_position' in params:
5128            query_params['start_position'] = params['start_position']
5129        if 'user_ids' in params:
5130            query_params['user_ids'] = params['user_ids']
5131
5132        header_params = {}
5133
5134        form_params = []
5135        local_var_files = {}
5136
5137        body_params = None
5138        # HTTP header `Accept`
5139        header_params['Accept'] = self.api_client.\
5140            select_header_accept(['application/json'])
5141
5142        # Authentication setting
5143        auth_settings = []
5144
5145        return self.api_client.call_api(resource_path, 'GET',
5146                                        path_params,
5147                                        query_params,
5148                                        header_params,
5149                                        body=body_params,
5150                                        post_params=form_params,
5151                                        files=local_var_files,
5152                                        response_type='AccountSharedAccess',
5153                                        auth_settings=auth_settings,
5154                                        callback=params.get('callback'),
5155                                        _return_http_data_only=params.get('_return_http_data_only'),
5156                                        _preload_content=params.get('_preload_content', True),
5157                                        _request_timeout=params.get('_request_timeout'),
5158                                        collection_formats=collection_formats)
5159
5160    def list_signature_providers(self, account_id, **kwargs):
5161        """
5162        Returns Account available signature providers for specified account.
5163        Returns a list of signature providers that the specified account can use.
5164        This method makes a synchronous HTTP request by default. To make an
5165        asynchronous HTTP request, please define a `callback` function
5166        to be invoked when receiving the response.
5167        >>> def callback_function(response):
5168        >>>     pprint(response)
5169        >>>
5170        >>> thread = api.list_signature_providers(account_id, callback=callback_function)
5171
5172        :param callback function: The callback function
5173            for asynchronous request. (optional)
5174        :param str account_id: The external account number (int) or account ID Guid. (required)
5175        :return: AccountSignatureProviders
5176                 If the method is called asynchronously,
5177                 returns the request thread.
5178        """
5179        kwargs['_return_http_data_only'] = True
5180        if kwargs.get('callback'):
5181            return self.list_signature_providers_with_http_info(account_id, **kwargs)
5182        else:
5183            (data) = self.list_signature_providers_with_http_info(account_id, **kwargs)
5184            return data
5185
5186    def list_signature_providers_with_http_info(self, account_id, **kwargs):
5187        """
5188        Returns Account available signature providers for specified account.
5189        Returns a list of signature providers that the specified account can use.
5190        This method makes a synchronous HTTP request by default. To make an
5191        asynchronous HTTP request, please define a `callback` function
5192        to be invoked when receiving the response.
5193        >>> def callback_function(response):
5194        >>>     pprint(response)
5195        >>>
5196        >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function)
5197
5198        :param callback function: The callback function
5199            for asynchronous request. (optional)
5200        :param str account_id: The external account number (int) or account ID Guid. (required)
5201        :return: AccountSignatureProviders
5202                 If the method is called asynchronously,
5203                 returns the request thread.
5204        """
5205
5206        all_params = ['account_id']
5207        all_params.append('callback')
5208        all_params.append('_return_http_data_only')
5209        all_params.append('_preload_content')
5210        all_params.append('_request_timeout')
5211
5212        params = locals()
5213        for key, val in iteritems(params['kwargs']):
5214            if key not in all_params:
5215                raise TypeError(
5216                    "Got an unexpected keyword argument '%s'"
5217                    " to method list_signature_providers" % key
5218                )
5219            params[key] = val
5220        del params['kwargs']
5221        # verify the required parameter 'account_id' is set
5222        if ('account_id' not in params) or (params['account_id'] is None):
5223            raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`")
5224
5225
5226        collection_formats = {}
5227
5228        resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json')
5229        path_params = {}
5230        if 'account_id' in params:
5231            path_params['accountId'] = params['account_id']
5232
5233        query_params = {}
5234
5235        header_params = {}
5236
5237        form_params = []
5238        local_var_files = {}
5239
5240        body_params = None
5241        # HTTP header `Accept`
5242        header_params['Accept'] = self.api_client.\
5243            select_header_accept(['application/json'])
5244
5245        # Authentication setting
5246        auth_settings = []
5247
5248        return self.api_client.call_api(resource_path, 'GET',
5249                                        path_params,
5250                                        query_params,
5251                                        header_params,
5252                                        body=body_params,
5253                                        post_params=form_params,
5254                                        files=local_var_files,
5255                                        response_type='AccountSignatureProviders',
5256                                        auth_settings=auth_settings,
5257                                        callback=params.get('callback'),
5258                                        _return_http_data_only=params.get('_return_http_data_only'),
5259                                        _preload_content=params.get('_preload_content', True),
5260                                        _request_timeout=params.get('_request_timeout'),
5261                                        collection_formats=collection_formats)
5262
5263    def list_unsupported_file_types(self, account_id, **kwargs):
5264        """
5265        Gets a list of unsupported file types.
5266        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5267        This method makes a synchronous HTTP request by default. To make an
5268        asynchronous HTTP request, please define a `callback` function
5269        to be invoked when receiving the response.
5270        >>> def callback_function(response):
5271        >>>     pprint(response)
5272        >>>
5273        >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function)
5274
5275        :param callback function: The callback function
5276            for asynchronous request. (optional)
5277        :param str account_id: The external account number (int) or account ID Guid. (required)
5278        :return: FileTypeList
5279                 If the method is called asynchronously,
5280                 returns the request thread.
5281        """
5282        kwargs['_return_http_data_only'] = True
5283        if kwargs.get('callback'):
5284            return self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5285        else:
5286            (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5287            return data
5288
5289    def list_unsupported_file_types_with_http_info(self, account_id, **kwargs):
5290        """
5291        Gets a list of unsupported file types.
5292        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5293        This method makes a synchronous HTTP request by default. To make an
5294        asynchronous HTTP request, please define a `callback` function
5295        to be invoked when receiving the response.
5296        >>> def callback_function(response):
5297        >>>     pprint(response)
5298        >>>
5299        >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function)
5300
5301        :param callback function: The callback function
5302            for asynchronous request. (optional)
5303        :param str account_id: The external account number (int) or account ID Guid. (required)
5304        :return: FileTypeList
5305                 If the method is called asynchronously,
5306                 returns the request thread.
5307        """
5308
5309        all_params = ['account_id']
5310        all_params.append('callback')
5311        all_params.append('_return_http_data_only')
5312        all_params.append('_preload_content')
5313        all_params.append('_request_timeout')
5314
5315        params = locals()
5316        for key, val in iteritems(params['kwargs']):
5317            if key not in all_params:
5318                raise TypeError(
5319                    "Got an unexpected keyword argument '%s'"
5320                    " to method list_unsupported_file_types" % key
5321                )
5322            params[key] = val
5323        del params['kwargs']
5324        # verify the required parameter 'account_id' is set
5325        if ('account_id' not in params) or (params['account_id'] is None):
5326            raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`")
5327
5328
5329        collection_formats = {}
5330
5331        resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json')
5332        path_params = {}
5333        if 'account_id' in params:
5334            path_params['accountId'] = params['account_id']
5335
5336        query_params = {}
5337
5338        header_params = {}
5339
5340        form_params = []
5341        local_var_files = {}
5342
5343        body_params = None
5344        # HTTP header `Accept`
5345        header_params['Accept'] = self.api_client.\
5346            select_header_accept(['application/json'])
5347
5348        # Authentication setting
5349        auth_settings = []
5350
5351        return self.api_client.call_api(resource_path, 'GET',
5352                                        path_params,
5353                                        query_params,
5354                                        header_params,
5355                                        body=body_params,
5356                                        post_params=form_params,
5357                                        files=local_var_files,
5358                                        response_type='FileTypeList',
5359                                        auth_settings=auth_settings,
5360                                        callback=params.get('callback'),
5361                                        _return_http_data_only=params.get('_return_http_data_only'),
5362                                        _preload_content=params.get('_preload_content', True),
5363                                        _request_timeout=params.get('_request_timeout'),
5364                                        collection_formats=collection_formats)
5365
5366    def un_favorite_template(self, account_id, **kwargs):
5367        """
5368        Unfavorite a template
5369        
5370        This method makes a synchronous HTTP request by default. To make an
5371        asynchronous HTTP request, please define a `callback` function
5372        to be invoked when receiving the response.
5373        >>> def callback_function(response):
5374        >>>     pprint(response)
5375        >>>
5376        >>> thread = api.un_favorite_template(account_id, callback=callback_function)
5377
5378        :param callback function: The callback function
5379            for asynchronous request. (optional)
5380        :param str account_id: The external account number (int) or account ID Guid. (required)
5381        :param FavoriteTemplatesInfo favorite_templates_info:
5382        :return: FavoriteTemplatesInfo
5383                 If the method is called asynchronously,
5384                 returns the request thread.
5385        """
5386        kwargs['_return_http_data_only'] = True
5387        if kwargs.get('callback'):
5388            return self.un_favorite_template_with_http_info(account_id, **kwargs)
5389        else:
5390            (data) = self.un_favorite_template_with_http_info(account_id, **kwargs)
5391            return data
5392
5393    def un_favorite_template_with_http_info(self, account_id, **kwargs):
5394        """
5395        Unfavorite a template
5396        
5397        This method makes a synchronous HTTP request by default. To make an
5398        asynchronous HTTP request, please define a `callback` function
5399        to be invoked when receiving the response.
5400        >>> def callback_function(response):
5401        >>>     pprint(response)
5402        >>>
5403        >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function)
5404
5405        :param callback function: The callback function
5406            for asynchronous request. (optional)
5407        :param str account_id: The external account number (int) or account ID Guid. (required)
5408        :param FavoriteTemplatesInfo favorite_templates_info:
5409        :return: FavoriteTemplatesInfo
5410                 If the method is called asynchronously,
5411                 returns the request thread.
5412        """
5413
5414        all_params = ['account_id', 'favorite_templates_info']
5415        all_params.append('callback')
5416        all_params.append('_return_http_data_only')
5417        all_params.append('_preload_content')
5418        all_params.append('_request_timeout')
5419
5420        params = locals()
5421        for key, val in iteritems(params['kwargs']):
5422            if key not in all_params:
5423                raise TypeError(
5424                    "Got an unexpected keyword argument '%s'"
5425                    " to method un_favorite_template" % key
5426                )
5427            params[key] = val
5428        del params['kwargs']
5429        # verify the required parameter 'account_id' is set
5430        if ('account_id' not in params) or (params['account_id'] is None):
5431            raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`")
5432
5433
5434        collection_formats = {}
5435
5436        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
5437        path_params = {}
5438        if 'account_id' in params:
5439            path_params['accountId'] = params['account_id']
5440
5441        query_params = {}
5442
5443        header_params = {}
5444
5445        form_params = []
5446        local_var_files = {}
5447
5448        body_params = None
5449        if 'favorite_templates_info' in params:
5450            body_params = params['favorite_templates_info']
5451        # HTTP header `Accept`
5452        header_params['Accept'] = self.api_client.\
5453            select_header_accept(['application/json'])
5454
5455        # Authentication setting
5456        auth_settings = []
5457
5458        return self.api_client.call_api(resource_path, 'DELETE',
5459                                        path_params,
5460                                        query_params,
5461                                        header_params,
5462                                        body=body_params,
5463                                        post_params=form_params,
5464                                        files=local_var_files,
5465                                        response_type='FavoriteTemplatesInfo',
5466                                        auth_settings=auth_settings,
5467                                        callback=params.get('callback'),
5468                                        _return_http_data_only=params.get('_return_http_data_only'),
5469                                        _preload_content=params.get('_preload_content', True),
5470                                        _request_timeout=params.get('_request_timeout'),
5471                                        collection_formats=collection_formats)
5472
5473    def update_account_signature(self, account_id, **kwargs):
5474        """
5475        Updates a account signature.
5476        
5477        This method makes a synchronous HTTP request by default. To make an
5478        asynchronous HTTP request, please define a `callback` function
5479        to be invoked when receiving the response.
5480        >>> def callback_function(response):
5481        >>>     pprint(response)
5482        >>>
5483        >>> thread = api.update_account_signature(account_id, callback=callback_function)
5484
5485        :param callback function: The callback function
5486            for asynchronous request. (optional)
5487        :param str account_id: The external account number (int) or account ID Guid. (required)
5488        :param AccountSignaturesInformation account_signatures_information:
5489        :return: AccountSignaturesInformation
5490                 If the method is called asynchronously,
5491                 returns the request thread.
5492        """
5493        kwargs['_return_http_data_only'] = True
5494        if kwargs.get('callback'):
5495            return self.update_account_signature_with_http_info(account_id, **kwargs)
5496        else:
5497            (data) = self.update_account_signature_with_http_info(account_id, **kwargs)
5498            return data
5499
5500    def update_account_signature_with_http_info(self, account_id, **kwargs):
5501        """
5502        Updates a account signature.
5503        
5504        This method makes a synchronous HTTP request by default. To make an
5505        asynchronous HTTP request, please define a `callback` function
5506        to be invoked when receiving the response.
5507        >>> def callback_function(response):
5508        >>>     pprint(response)
5509        >>>
5510        >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function)
5511
5512        :param callback function: The callback function
5513            for asynchronous request. (optional)
5514        :param str account_id: The external account number (int) or account ID Guid. (required)
5515        :param AccountSignaturesInformation account_signatures_information:
5516        :return: AccountSignaturesInformation
5517                 If the method is called asynchronously,
5518                 returns the request thread.
5519        """
5520
5521        all_params = ['account_id', 'account_signatures_information']
5522        all_params.append('callback')
5523        all_params.append('_return_http_data_only')
5524        all_params.append('_preload_content')
5525        all_params.append('_request_timeout')
5526
5527        params = locals()
5528        for key, val in iteritems(params['kwargs']):
5529            if key not in all_params:
5530                raise TypeError(
5531                    "Got an unexpected keyword argument '%s'"
5532                    " to method update_account_signature" % key
5533                )
5534            params[key] = val
5535        del params['kwargs']
5536        # verify the required parameter 'account_id' is set
5537        if ('account_id' not in params) or (params['account_id'] is None):
5538            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`")
5539
5540
5541        collection_formats = {}
5542
5543        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
5544        path_params = {}
5545        if 'account_id' in params:
5546            path_params['accountId'] = params['account_id']
5547
5548        query_params = {}
5549
5550        header_params = {}
5551
5552        form_params = []
5553        local_var_files = {}
5554
5555        body_params = None
5556        if 'account_signatures_information' in params:
5557            body_params = params['account_signatures_information']
5558        # HTTP header `Accept`
5559        header_params['Accept'] = self.api_client.\
5560            select_header_accept(['application/json'])
5561
5562        # Authentication setting
5563        auth_settings = []
5564
5565        return self.api_client.call_api(resource_path, 'PUT',
5566                                        path_params,
5567                                        query_params,
5568                                        header_params,
5569                                        body=body_params,
5570                                        post_params=form_params,
5571                                        files=local_var_files,
5572                                        response_type='AccountSignaturesInformation',
5573                                        auth_settings=auth_settings,
5574                                        callback=params.get('callback'),
5575                                        _return_http_data_only=params.get('_return_http_data_only'),
5576                                        _preload_content=params.get('_preload_content', True),
5577                                        _request_timeout=params.get('_request_timeout'),
5578                                        collection_formats=collection_formats)
5579
5580    def update_account_signature_by_id(self, account_id, signature_id, **kwargs):
5581        """
5582        Updates a account signature.
5583        
5584        This method makes a synchronous HTTP request by default. To make an
5585        asynchronous HTTP request, please define a `callback` function
5586        to be invoked when receiving the response.
5587        >>> def callback_function(response):
5588        >>>     pprint(response)
5589        >>>
5590        >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function)
5591
5592        :param callback function: The callback function
5593            for asynchronous request. (optional)
5594        :param str account_id: The external account number (int) or account ID Guid. (required)
5595        :param str signature_id: The ID of the signature being accessed. (required)
5596        :param str close_existing_signature:
5597        :param AccountSignatureDefinition account_signature_definition:
5598        :return: AccountSignature
5599                 If the method is called asynchronously,
5600                 returns the request thread.
5601        """
5602        kwargs['_return_http_data_only'] = True
5603        if kwargs.get('callback'):
5604            return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5605        else:
5606            (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5607            return data
5608
5609    def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs):
5610        """
5611        Updates a account signature.
5612        
5613        This method makes a synchronous HTTP request by default. To make an
5614        asynchronous HTTP request, please define a `callback` function
5615        to be invoked when receiving the response.
5616        >>> def callback_function(response):
5617        >>>     pprint(response)
5618        >>>
5619        >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
5620
5621        :param callback function: The callback function
5622            for asynchronous request. (optional)
5623        :param str account_id: The external account number (int) or account ID Guid. (required)
5624        :param str signature_id: The ID of the signature being accessed. (required)
5625        :param str close_existing_signature:
5626        :param AccountSignatureDefinition account_signature_definition:
5627        :return: AccountSignature
5628                 If the method is called asynchronously,
5629                 returns the request thread.
5630        """
5631
5632        all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition']
5633        all_params.append('callback')
5634        all_params.append('_return_http_data_only')
5635        all_params.append('_preload_content')
5636        all_params.append('_request_timeout')
5637
5638        params = locals()
5639        for key, val in iteritems(params['kwargs']):
5640            if key not in all_params:
5641                raise TypeError(
5642                    "Got an unexpected keyword argument '%s'"
5643                    " to method update_account_signature_by_id" % key
5644                )
5645            params[key] = val
5646        del params['kwargs']
5647        # verify the required parameter 'account_id' is set
5648        if ('account_id' not in params) or (params['account_id'] is None):
5649            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`")
5650        # verify the required parameter 'signature_id' is set
5651        if ('signature_id' not in params) or (params['signature_id'] is None):
5652            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`")
5653
5654
5655        collection_formats = {}
5656
5657        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
5658        path_params = {}
5659        if 'account_id' in params:
5660            path_params['accountId'] = params['account_id']
5661        if 'signature_id' in params:
5662            path_params['signatureId'] = params['signature_id']
5663
5664        query_params = {}
5665        if 'close_existing_signature' in params:
5666            query_params['close_existing_signature'] = params['close_existing_signature']
5667
5668        header_params = {}
5669
5670        form_params = []
5671        local_var_files = {}
5672
5673        body_params = None
5674        if 'account_signature_definition' in params:
5675            body_params = params['account_signature_definition']
5676        # HTTP header `Accept`
5677        header_params['Accept'] = self.api_client.\
5678            select_header_accept(['application/json'])
5679
5680        # Authentication setting
5681        auth_settings = []
5682
5683        return self.api_client.call_api(resource_path, 'PUT',
5684                                        path_params,
5685                                        query_params,
5686                                        header_params,
5687                                        body=body_params,
5688                                        post_params=form_params,
5689                                        files=local_var_files,
5690                                        response_type='AccountSignature',
5691                                        auth_settings=auth_settings,
5692                                        callback=params.get('callback'),
5693                                        _return_http_data_only=params.get('_return_http_data_only'),
5694                                        _preload_content=params.get('_preload_content', True),
5695                                        _request_timeout=params.get('_request_timeout'),
5696                                        collection_formats=collection_formats)
5697
5698    def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
5699        """
5700        Sets a signature, initials, or stamps image.
5701        
5702        This method makes a synchronous HTTP request by default. To make an
5703        asynchronous HTTP request, please define a `callback` function
5704        to be invoked when receiving the response.
5705        >>> def callback_function(response):
5706        >>>     pprint(response)
5707        >>>
5708        >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
5709
5710        :param callback function: The callback function
5711            for asynchronous request. (optional)
5712        :param str account_id: The external account number (int) or account ID Guid. (required)
5713        :param str image_type: One of **signature_image** or **initials_image**. (required)
5714        :param str signature_id: The ID of the signature being accessed. (required)
5715        :param str transparent_png:
5716        :return: AccountSignature
5717                 If the method is called asynchronously,
5718                 returns the request thread.
5719        """
5720        kwargs['_return_http_data_only'] = True
5721        if kwargs.get('callback'):
5722            return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5723        else:
5724            (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5725            return data
5726
5727    def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
5728        """
5729        Sets a signature, initials, or stamps image.
5730        
5731        This method makes a synchronous HTTP request by default. To make an
5732        asynchronous HTTP request, please define a `callback` function
5733        to be invoked when receiving the response.
5734        >>> def callback_function(response):
5735        >>>     pprint(response)
5736        >>>
5737        >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
5738
5739        :param callback function: The callback function
5740            for asynchronous request. (optional)
5741        :param str account_id: The external account number (int) or account ID Guid. (required)
5742        :param str image_type: One of **signature_image** or **initials_image**. (required)
5743        :param str signature_id: The ID of the signature being accessed. (required)
5744        :param str transparent_png:
5745        :return: AccountSignature
5746                 If the method is called asynchronously,
5747                 returns the request thread.
5748        """
5749
5750        all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png']
5751        all_params.append('callback')
5752        all_params.append('_return_http_data_only')
5753        all_params.append('_preload_content')
5754        all_params.append('_request_timeout')
5755
5756        params = locals()
5757        for key, val in iteritems(params['kwargs']):
5758            if key not in all_params:
5759                raise TypeError(
5760                    "Got an unexpected keyword argument '%s'"
5761                    " to method update_account_signature_image" % key
5762                )
5763            params[key] = val
5764        del params['kwargs']
5765        # verify the required parameter 'account_id' is set
5766        if ('account_id' not in params) or (params['account_id'] is None):
5767            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`")
5768        # verify the required parameter 'image_type' is set
5769        if ('image_type' not in params) or (params['image_type'] is None):
5770            raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`")
5771        # verify the required parameter 'signature_id' is set
5772        if ('signature_id' not in params) or (params['signature_id'] is None):
5773            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`")
5774
5775
5776        collection_formats = {}
5777
5778        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
5779        path_params = {}
5780        if 'account_id' in params:
5781            path_params['accountId'] = params['account_id']
5782        if 'image_type' in params:
5783            path_params['imageType'] = params['image_type']
5784        if 'signature_id' in params:
5785            path_params['signatureId'] = params['signature_id']
5786
5787        query_params = {}
5788        if 'transparent_png' in params:
5789            query_params['transparent_png'] = params['transparent_png']
5790
5791        header_params = {}
5792
5793        form_params = []
5794        local_var_files = {}
5795
5796        body_params = None
5797        # HTTP header `Accept`
5798        header_params['Accept'] = self.api_client.\
5799            select_header_accept(['application/json'])
5800
5801        # HTTP header `Content-Type`
5802        header_params['Content-Type'] = self.api_client.\
5803            select_header_content_type(['image/gif'])
5804
5805        # Authentication setting
5806        auth_settings = []
5807
5808        return self.api_client.call_api(resource_path, 'PUT',
5809                                        path_params,
5810                                        query_params,
5811                                        header_params,
5812                                        body=body_params,
5813                                        post_params=form_params,
5814                                        files=local_var_files,
5815                                        response_type='AccountSignature',
5816                                        auth_settings=auth_settings,
5817                                        callback=params.get('callback'),
5818                                        _return_http_data_only=params.get('_return_http_data_only'),
5819                                        _preload_content=params.get('_preload_content', True),
5820                                        _request_timeout=params.get('_request_timeout'),
5821                                        collection_formats=collection_formats)
5822
5823    def update_account_tab_settings(self, account_id, **kwargs):
5824        """
5825        Modifies tab settings for specified account
5826        This method modifies the tab types and tab functionality that is enabled for an account.
5827        This method makes a synchronous HTTP request by default. To make an
5828        asynchronous HTTP request, please define a `callback` function
5829        to be invoked when receiving the response.
5830        >>> def callback_function(response):
5831        >>>     pprint(response)
5832        >>>
5833        >>> thread = api.update_account_tab_settings(account_id, callback=callback_function)
5834
5835        :param callback function: The callback function
5836            for asynchronous request. (optional)
5837        :param str account_id: The external account number (int) or account ID Guid. (required)
5838        :param TabAccountSettings tab_account_settings:
5839        :return: TabAccountSettings
5840                 If the method is called asynchronously,
5841                 returns the request thread.
5842        """
5843        kwargs['_return_http_data_only'] = True
5844        if kwargs.get('callback'):
5845            return self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5846        else:
5847            (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5848            return data
5849
5850    def update_account_tab_settings_with_http_info(self, account_id, **kwargs):
5851        """
5852        Modifies tab settings for specified account
5853        This method modifies the tab types and tab functionality that is enabled for an account.
5854        This method makes a synchronous HTTP request by default. To make an
5855        asynchronous HTTP request, please define a `callback` function
5856        to be invoked when receiving the response.
5857        >>> def callback_function(response):
5858        >>>     pprint(response)
5859        >>>
5860        >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function)
5861
5862        :param callback function: The callback function
5863            for asynchronous request. (optional)
5864        :param str account_id: The external account number (int) or account ID Guid. (required)
5865        :param TabAccountSettings tab_account_settings:
5866        :return: TabAccountSettings
5867                 If the method is called asynchronously,
5868                 returns the request thread.
5869        """
5870
5871        all_params = ['account_id', 'tab_account_settings']
5872        all_params.append('callback')
5873        all_params.append('_return_http_data_only')
5874        all_params.append('_preload_content')
5875        all_params.append('_request_timeout')
5876
5877        params = locals()
5878        for key, val in iteritems(params['kwargs']):
5879            if key not in all_params:
5880                raise TypeError(
5881                    "Got an unexpected keyword argument '%s'"
5882                    " to method update_account_tab_settings" % key
5883                )
5884            params[key] = val
5885        del params['kwargs']
5886        # verify the required parameter 'account_id' is set
5887        if ('account_id' not in params) or (params['account_id'] is None):
5888            raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`")
5889
5890
5891        collection_formats = {}
5892
5893        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
5894        path_params = {}
5895        if 'account_id' in params:
5896            path_params['accountId'] = params['account_id']
5897
5898        query_params = {}
5899
5900        header_params = {}
5901
5902        form_params = []
5903        local_var_files = {}
5904
5905        body_params = None
5906        if 'tab_account_settings' in params:
5907            body_params = params['tab_account_settings']
5908        # HTTP header `Accept`
5909        header_params['Accept'] = self.api_client.\
5910            select_header_accept(['application/json'])
5911
5912        # Authentication setting
5913        auth_settings = []
5914
5915        return self.api_client.call_api(resource_path, 'PUT',
5916                                        path_params,
5917                                        query_params,
5918                                        header_params,
5919                                        body=body_params,
5920                                        post_params=form_params,
5921                                        files=local_var_files,
5922                                        response_type='TabAccountSettings',
5923                                        auth_settings=auth_settings,
5924                                        callback=params.get('callback'),
5925                                        _return_http_data_only=params.get('_return_http_data_only'),
5926                                        _preload_content=params.get('_preload_content', True),
5927                                        _request_timeout=params.get('_request_timeout'),
5928                                        collection_formats=collection_formats)
5929
5930    def update_brand(self, account_id, brand_id, **kwargs):
5931        """
5932        Updates an existing brand.
5933        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5934        This method makes a synchronous HTTP request by default. To make an
5935        asynchronous HTTP request, please define a `callback` function
5936        to be invoked when receiving the response.
5937        >>> def callback_function(response):
5938        >>>     pprint(response)
5939        >>>
5940        >>> thread = api.update_brand(account_id, brand_id, callback=callback_function)
5941
5942        :param callback function: The callback function
5943            for asynchronous request. (optional)
5944        :param str account_id: The external account number (int) or account ID Guid. (required)
5945        :param str brand_id: The unique identifier of a brand. (required)
5946        :param str replace_brand:
5947        :param Brand brand:
5948        :return: Brand
5949                 If the method is called asynchronously,
5950                 returns the request thread.
5951        """
5952        kwargs['_return_http_data_only'] = True
5953        if kwargs.get('callback'):
5954            return self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5955        else:
5956            (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5957            return data
5958
5959    def update_brand_with_http_info(self, account_id, brand_id, **kwargs):
5960        """
5961        Updates an existing brand.
5962        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5963        This method makes a synchronous HTTP request by default. To make an
5964        asynchronous HTTP request, please define a `callback` function
5965        to be invoked when receiving the response.
5966        >>> def callback_function(response):
5967        >>>     pprint(response)
5968        >>>
5969        >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
5970
5971        :param callback function: The callback function
5972            for asynchronous request. (optional)
5973        :param str account_id: The external account number (int) or account ID Guid. (required)
5974        :param str brand_id: The unique identifier of a brand. (required)
5975        :param str replace_brand:
5976        :param Brand brand:
5977        :return: Brand
5978                 If the method is called asynchronously,
5979                 returns the request thread.
5980        """
5981
5982        all_params = ['account_id', 'brand_id', 'replace_brand', 'brand']
5983        all_params.append('callback')
5984        all_params.append('_return_http_data_only')
5985        all_params.append('_preload_content')
5986        all_params.append('_request_timeout')
5987
5988        params = locals()
5989        for key, val in iteritems(params['kwargs']):
5990            if key not in all_params:
5991                raise TypeError(
5992                    "Got an unexpected keyword argument '%s'"
5993                    " to method update_brand" % key
5994                )
5995            params[key] = val
5996        del params['kwargs']
5997        # verify the required parameter 'account_id' is set
5998        if ('account_id' not in params) or (params['account_id'] is None):
5999            raise ValueError("Missing the required parameter `account_id` when calling `update_brand`")
6000        # verify the required parameter 'brand_id' is set
6001        if ('brand_id' not in params) or (params['brand_id'] is None):
6002            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`")
6003
6004
6005        collection_formats = {}
6006
6007        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
6008        path_params = {}
6009        if 'account_id' in params:
6010            path_params['accountId'] = params['account_id']
6011        if 'brand_id' in params:
6012            path_params['brandId'] = params['brand_id']
6013
6014        query_params = {}
6015        if 'replace_brand' in params:
6016            query_params['replace_brand'] = params['replace_brand']
6017
6018        header_params = {}
6019
6020        form_params = []
6021        local_var_files = {}
6022
6023        body_params = None
6024        if 'brand' in params:
6025            body_params = params['brand']
6026        # HTTP header `Accept`
6027        header_params['Accept'] = self.api_client.\
6028            select_header_accept(['application/json'])
6029
6030        # Authentication setting
6031        auth_settings = []
6032
6033        return self.api_client.call_api(resource_path, 'PUT',
6034                                        path_params,
6035                                        query_params,
6036                                        header_params,
6037                                        body=body_params,
6038                                        post_params=form_params,
6039                                        files=local_var_files,
6040                                        response_type='Brand',
6041                                        auth_settings=auth_settings,
6042                                        callback=params.get('callback'),
6043                                        _return_http_data_only=params.get('_return_http_data_only'),
6044                                        _preload_content=params.get('_preload_content', True),
6045                                        _request_timeout=params.get('_request_timeout'),
6046                                        collection_formats=collection_formats)
6047
6048    def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6049        """
6050        Put one branding logo.
6051        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6052        This method makes a synchronous HTTP request by default. To make an
6053        asynchronous HTTP request, please define a `callback` function
6054        to be invoked when receiving the response.
6055        >>> def callback_function(response):
6056        >>>     pprint(response)
6057        >>>
6058        >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6059
6060        :param callback function: The callback function
6061            for asynchronous request. (optional)
6062        :param str account_id: The external account number (int) or account ID GUID. (required)
6063        :param str brand_id: The ID of the brand. (required)
6064        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6065        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6066        :return: None
6067                 If the method is called asynchronously,
6068                 returns the request thread.
6069        """
6070        kwargs['_return_http_data_only'] = True
6071        if kwargs.get('callback'):
6072            return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6073        else:
6074            (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6075            return data
6076
6077    def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6078        """
6079        Put one branding logo.
6080        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6081        This method makes a synchronous HTTP request by default. To make an
6082        asynchronous HTTP request, please define a `callback` function
6083        to be invoked when receiving the response.
6084        >>> def callback_function(response):
6085        >>>     pprint(response)
6086        >>>
6087        >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6088
6089        :param callback function: The callback function
6090            for asynchronous request. (optional)
6091        :param str account_id: The external account number (int) or account ID GUID. (required)
6092        :param str brand_id: The ID of the brand. (required)
6093        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6094        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6095        :return: None
6096                 If the method is called asynchronously,
6097                 returns the request thread.
6098        """
6099
6100        all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes']
6101        all_params.append('callback')
6102        all_params.append('_return_http_data_only')
6103        all_params.append('_preload_content')
6104        all_params.append('_request_timeout')
6105
6106        params = locals()
6107        for key, val in iteritems(params['kwargs']):
6108            if key not in all_params:
6109                raise TypeError(
6110                    "Got an unexpected keyword argument '%s'"
6111                    " to method update_brand_logo_by_type" % key
6112                )
6113            params[key] = val
6114        del params['kwargs']
6115        # verify the required parameter 'account_id' is set
6116        if ('account_id' not in params) or (params['account_id'] is None):
6117            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`")
6118        # verify the required parameter 'brand_id' is set
6119        if ('brand_id' not in params) or (params['brand_id'] is None):
6120            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`")
6121        # verify the required parameter 'logo_type' is set
6122        if ('logo_type' not in params) or (params['logo_type'] is None):
6123            raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`")
6124        # verify the required parameter 'logo_file_bytes' is set
6125        if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None):
6126            raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`")
6127
6128
6129        collection_formats = {}
6130
6131        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
6132        path_params = {}
6133        if 'account_id' in params:
6134            path_params['accountId'] = params['account_id']
6135        if 'brand_id' in params:
6136            path_params['brandId'] = params['brand_id']
6137        if 'logo_type' in params:
6138            path_params['logoType'] = params['logo_type']
6139
6140        query_params = {}
6141
6142        header_params = {}
6143
6144        form_params = []
6145        local_var_files = {}
6146
6147        body_params = None
6148        if 'logo_file_bytes' in params:
6149            body_params = params['logo_file_bytes']
6150        # HTTP header `Accept`
6151        header_params['Accept'] = self.api_client.\
6152            select_header_accept(['application/json'])
6153
6154        # HTTP header `Content-Type`
6155        header_params['Content-Type'] = self.api_client.\
6156            select_header_content_type(['image/png'])
6157
6158        # Authentication setting
6159        auth_settings = []
6160
6161        return self.api_client.call_api(resource_path, 'PUT',
6162                                        path_params,
6163                                        query_params,
6164                                        header_params,
6165                                        body=body_params,
6166                                        post_params=form_params,
6167                                        files=local_var_files,
6168                                        response_type=None,
6169                                        auth_settings=auth_settings,
6170                                        callback=params.get('callback'),
6171                                        _return_http_data_only=params.get('_return_http_data_only'),
6172                                        _preload_content=params.get('_preload_content', True),
6173                                        _request_timeout=params.get('_request_timeout'),
6174                                        collection_formats=collection_formats)
6175
6176    def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6177        """
6178        Uploads a branding resource file.
6179        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6180        This method makes a synchronous HTTP request by default. To make an
6181        asynchronous HTTP request, please define a `callback` function
6182        to be invoked when receiving the response.
6183        >>> def callback_function(response):
6184        >>>     pprint(response)
6185        >>>
6186        >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6187
6188        :param callback function: The callback function
6189            for asynchronous request. (optional)
6190        :param str account_id: The external account number (int) or account ID GUID. (required)
6191        :param str brand_id: The ID of the brand. (required)
6192        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6193        :param file file_xml: Brand resource XML file. (required)
6194        :return: BrandResources
6195                 If the method is called asynchronously,
6196                 returns the request thread.
6197        """
6198        kwargs['_return_http_data_only'] = True
6199        if kwargs.get('callback'):
6200            return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6201        else:
6202            (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6203            return data
6204
6205    def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6206        """
6207        Uploads a branding resource file.
6208        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6209        This method makes a synchronous HTTP request by default. To make an
6210        asynchronous HTTP request, please define a `callback` function
6211        to be invoked when receiving the response.
6212        >>> def callback_function(response):
6213        >>>     pprint(response)
6214        >>>
6215        >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6216
6217        :param callback function: The callback function
6218            for asynchronous request. (optional)
6219        :param str account_id: The external account number (int) or account ID GUID. (required)
6220        :param str brand_id: The ID of the brand. (required)
6221        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6222        :param file file_xml: Brand resource XML file. (required)
6223        :return: BrandResources
6224                 If the method is called asynchronously,
6225                 returns the request thread.
6226        """
6227
6228        all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml']
6229        all_params.append('callback')
6230        all_params.append('_return_http_data_only')
6231        all_params.append('_preload_content')
6232        all_params.append('_request_timeout')
6233
6234        params = locals()
6235        for key, val in iteritems(params['kwargs']):
6236            if key not in all_params:
6237                raise TypeError(
6238                    "Got an unexpected keyword argument '%s'"
6239                    " to method update_brand_resources_by_content_type" % key
6240                )
6241            params[key] = val
6242        del params['kwargs']
6243        # verify the required parameter 'account_id' is set
6244        if ('account_id' not in params) or (params['account_id'] is None):
6245            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`")
6246        # verify the required parameter 'brand_id' is set
6247        if ('brand_id' not in params) or (params['brand_id'] is None):
6248            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`")
6249        # verify the required parameter 'resource_content_type' is set
6250        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
6251            raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`")
6252        # verify the required parameter 'file_xml' is set
6253        if ('file_xml' not in params) or (params['file_xml'] is None):
6254            raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`")
6255
6256
6257        collection_formats = {}
6258
6259        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
6260        path_params = {}
6261        if 'account_id' in params:
6262            path_params['accountId'] = params['account_id']
6263        if 'brand_id' in params:
6264            path_params['brandId'] = params['brand_id']
6265        if 'resource_content_type' in params:
6266            path_params['resourceContentType'] = params['resource_content_type']
6267
6268        query_params = {}
6269
6270        header_params = {}
6271
6272        form_params = []
6273        local_var_files = {}
6274        if 'file_xml' in params:
6275            local_var_files['file.xml'] = params['file_xml']
6276
6277        body_params = None
6278        # HTTP header `Accept`
6279        header_params['Accept'] = self.api_client.\
6280            select_header_accept(['application/json'])
6281
6282        # HTTP header `Content-Type`
6283        header_params['Content-Type'] = self.api_client.\
6284            select_header_content_type(['multipart/form-data'])
6285
6286        # Authentication setting
6287        auth_settings = []
6288
6289        return self.api_client.call_api(resource_path, 'PUT',
6290                                        path_params,
6291                                        query_params,
6292                                        header_params,
6293                                        body=body_params,
6294                                        post_params=form_params,
6295                                        files=local_var_files,
6296                                        response_type='BrandResources',
6297                                        auth_settings=auth_settings,
6298                                        callback=params.get('callback'),
6299                                        _return_http_data_only=params.get('_return_http_data_only'),
6300                                        _preload_content=params.get('_preload_content', True),
6301                                        _request_timeout=params.get('_request_timeout'),
6302                                        collection_formats=collection_formats)
6303
6304    def update_consumer_disclosure(self, account_id, lang_code, **kwargs):
6305        """
6306        Update Consumer Disclosure.
6307        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6308        This method makes a synchronous HTTP request by default. To make an
6309        asynchronous HTTP request, please define a `callback` function
6310        to be invoked when receiving the response.
6311        >>> def callback_function(response):
6312        >>>     pprint(response)
6313        >>>
6314        >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function)
6315
6316        :param callback function: The callback function
6317            for asynchronous request. (optional)
6318        :param str account_id: The external account number (int) or account ID Guid. (required)
6319        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6320        :param str include_metadata:
6321        :param ConsumerDisclosure consumer_disclosure:
6322        :return: ConsumerDisclosure
6323                 If the method is called asynchronously,
6324                 returns the request thread.
6325        """
6326        kwargs['_return_http_data_only'] = True
6327        if kwargs.get('callback'):
6328            return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6329        else:
6330            (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6331            return data
6332
6333    def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
6334        """
6335        Update Consumer Disclosure.
6336        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6337        This method makes a synchronous HTTP request by default. To make an
6338        asynchronous HTTP request, please define a `callback` function
6339        to be invoked when receiving the response.
6340        >>> def callback_function(response):
6341        >>>     pprint(response)
6342        >>>
6343        >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
6344
6345        :param callback function: The callback function
6346            for asynchronous request. (optional)
6347        :param str account_id: The external account number (int) or account ID Guid. (required)
6348        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6349        :param str include_metadata:
6350        :param ConsumerDisclosure consumer_disclosure:
6351        :return: ConsumerDisclosure
6352                 If the method is called asynchronously,
6353                 returns the request thread.
6354        """
6355
6356        all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure']
6357        all_params.append('callback')
6358        all_params.append('_return_http_data_only')
6359        all_params.append('_preload_content')
6360        all_params.append('_request_timeout')
6361
6362        params = locals()
6363        for key, val in iteritems(params['kwargs']):
6364            if key not in all_params:
6365                raise TypeError(
6366                    "Got an unexpected keyword argument '%s'"
6367                    " to method update_consumer_disclosure" % key
6368                )
6369            params[key] = val
6370        del params['kwargs']
6371        # verify the required parameter 'account_id' is set
6372        if ('account_id' not in params) or (params['account_id'] is None):
6373            raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`")
6374        # verify the required parameter 'lang_code' is set
6375        if ('lang_code' not in params) or (params['lang_code'] is None):
6376            raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`")
6377
6378
6379        collection_formats = {}
6380
6381        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
6382        path_params = {}
6383        if 'account_id' in params:
6384            path_params['accountId'] = params['account_id']
6385        if 'lang_code' in params:
6386            path_params['langCode'] = params['lang_code']
6387
6388        query_params = {}
6389        if 'include_metadata' in params:
6390            query_params['include_metadata'] = params['include_metadata']
6391
6392        header_params = {}
6393
6394        form_params = []
6395        local_var_files = {}
6396
6397        body_params = None
6398        if 'consumer_disclosure' in params:
6399            body_params = params['consumer_disclosure']
6400        # HTTP header `Accept`
6401        header_params['Accept'] = self.api_client.\
6402            select_header_accept(['application/json'])
6403
6404        # Authentication setting
6405        auth_settings = []
6406
6407        return self.api_client.call_api(resource_path, 'PUT',
6408                                        path_params,
6409                                        query_params,
6410                                        header_params,
6411                                        body=body_params,
6412                                        post_params=form_params,
6413                                        files=local_var_files,
6414                                        response_type='ConsumerDisclosure',
6415                                        auth_settings=auth_settings,
6416                                        callback=params.get('callback'),
6417                                        _return_http_data_only=params.get('_return_http_data_only'),
6418                                        _preload_content=params.get('_preload_content', True),
6419                                        _request_timeout=params.get('_request_timeout'),
6420                                        collection_formats=collection_formats)
6421
6422    def update_custom_field(self, account_id, custom_field_id, **kwargs):
6423        """
6424        Updates an existing account custom field.
6425        This method updates an existing account custom field.
6426        This method makes a synchronous HTTP request by default. To make an
6427        asynchronous HTTP request, please define a `callback` function
6428        to be invoked when receiving the response.
6429        >>> def callback_function(response):
6430        >>>     pprint(response)
6431        >>>
6432        >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function)
6433
6434        :param callback function: The callback function
6435            for asynchronous request. (optional)
6436        :param str account_id: The external account number (int) or account ID Guid. (required)
6437        :param str custom_field_id: (required)
6438        :param str apply_to_templates:
6439        :param CustomField custom_field:
6440        :return: CustomFields
6441                 If the method is called asynchronously,
6442                 returns the request thread.
6443        """
6444        kwargs['_return_http_data_only'] = True
6445        if kwargs.get('callback'):
6446            return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6447        else:
6448            (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6449            return data
6450
6451    def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
6452        """
6453        Updates an existing account custom field.
6454        This method updates an existing account custom field.
6455        This method makes a synchronous HTTP request by default. To make an
6456        asynchronous HTTP request, please define a `callback` function
6457        to be invoked when receiving the response.
6458        >>> def callback_function(response):
6459        >>>     pprint(response)
6460        >>>
6461        >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
6462
6463        :param callback function: The callback function
6464            for asynchronous request. (optional)
6465        :param str account_id: The external account number (int) or account ID Guid. (required)
6466        :param str custom_field_id: (required)
6467        :param str apply_to_templates:
6468        :param CustomField custom_field:
6469        :return: CustomFields
6470                 If the method is called asynchronously,
6471                 returns the request thread.
6472        """
6473
6474        all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field']
6475        all_params.append('callback')
6476        all_params.append('_return_http_data_only')
6477        all_params.append('_preload_content')
6478        all_params.append('_request_timeout')
6479
6480        params = locals()
6481        for key, val in iteritems(params['kwargs']):
6482            if key not in all_params:
6483                raise TypeError(
6484                    "Got an unexpected keyword argument '%s'"
6485                    " to method update_custom_field" % key
6486                )
6487            params[key] = val
6488        del params['kwargs']
6489        # verify the required parameter 'account_id' is set
6490        if ('account_id' not in params) or (params['account_id'] is None):
6491            raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`")
6492        # verify the required parameter 'custom_field_id' is set
6493        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
6494            raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`")
6495
6496
6497        collection_formats = {}
6498
6499        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
6500        path_params = {}
6501        if 'account_id' in params:
6502            path_params['accountId'] = params['account_id']
6503        if 'custom_field_id' in params:
6504            path_params['customFieldId'] = params['custom_field_id']
6505
6506        query_params = {}
6507        if 'apply_to_templates' in params:
6508            query_params['apply_to_templates'] = params['apply_to_templates']
6509
6510        header_params = {}
6511
6512        form_params = []
6513        local_var_files = {}
6514
6515        body_params = None
6516        if 'custom_field' in params:
6517            body_params = params['custom_field']
6518        # HTTP header `Accept`
6519        header_params['Accept'] = self.api_client.\
6520            select_header_accept(['application/json'])
6521
6522        # Authentication setting
6523        auth_settings = []
6524
6525        return self.api_client.call_api(resource_path, 'PUT',
6526                                        path_params,
6527                                        query_params,
6528                                        header_params,
6529                                        body=body_params,
6530                                        post_params=form_params,
6531                                        files=local_var_files,
6532                                        response_type='CustomFields',
6533                                        auth_settings=auth_settings,
6534                                        callback=params.get('callback'),
6535                                        _return_http_data_only=params.get('_return_http_data_only'),
6536                                        _preload_content=params.get('_preload_content', True),
6537                                        _request_timeout=params.get('_request_timeout'),
6538                                        collection_formats=collection_formats)
6539
6540    def update_e_note_configuration(self, account_id, **kwargs):
6541        """
6542        Updates configuration information for the eNote eOriginal integration.
6543        
6544        This method makes a synchronous HTTP request by default. To make an
6545        asynchronous HTTP request, please define a `callback` function
6546        to be invoked when receiving the response.
6547        >>> def callback_function(response):
6548        >>>     pprint(response)
6549        >>>
6550        >>> thread = api.update_e_note_configuration(account_id, callback=callback_function)
6551
6552        :param callback function: The callback function
6553            for asynchronous request. (optional)
6554        :param str account_id: The external account number (int) or account ID Guid. (required)
6555        :param ENoteConfiguration e_note_configuration:
6556        :return: ENoteConfiguration
6557                 If the method is called asynchronously,
6558                 returns the request thread.
6559        """
6560        kwargs['_return_http_data_only'] = True
6561        if kwargs.get('callback'):
6562            return self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6563        else:
6564            (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6565            return data
6566
6567    def update_e_note_configuration_with_http_info(self, account_id, **kwargs):
6568        """
6569        Updates configuration information for the eNote eOriginal integration.
6570        
6571        This method makes a synchronous HTTP request by default. To make an
6572        asynchronous HTTP request, please define a `callback` function
6573        to be invoked when receiving the response.
6574        >>> def callback_function(response):
6575        >>>     pprint(response)
6576        >>>
6577        >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function)
6578
6579        :param callback function: The callback function
6580            for asynchronous request. (optional)
6581        :param str account_id: The external account number (int) or account ID Guid. (required)
6582        :param ENoteConfiguration e_note_configuration:
6583        :return: ENoteConfiguration
6584                 If the method is called asynchronously,
6585                 returns the request thread.
6586        """
6587
6588        all_params = ['account_id', 'e_note_configuration']
6589        all_params.append('callback')
6590        all_params.append('_return_http_data_only')
6591        all_params.append('_preload_content')
6592        all_params.append('_request_timeout')
6593
6594        params = locals()
6595        for key, val in iteritems(params['kwargs']):
6596            if key not in all_params:
6597                raise TypeError(
6598                    "Got an unexpected keyword argument '%s'"
6599                    " to method update_e_note_configuration" % key
6600                )
6601            params[key] = val
6602        del params['kwargs']
6603        # verify the required parameter 'account_id' is set
6604        if ('account_id' not in params) or (params['account_id'] is None):
6605            raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`")
6606
6607
6608        collection_formats = {}
6609
6610        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
6611        path_params = {}
6612        if 'account_id' in params:
6613            path_params['accountId'] = params['account_id']
6614
6615        query_params = {}
6616
6617        header_params = {}
6618
6619        form_params = []
6620        local_var_files = {}
6621
6622        body_params = None
6623        if 'e_note_configuration' in params:
6624            body_params = params['e_note_configuration']
6625        # HTTP header `Accept`
6626        header_params['Accept'] = self.api_client.\
6627            select_header_accept(['application/json'])
6628
6629        # Authentication setting
6630        auth_settings = []
6631
6632        return self.api_client.call_api(resource_path, 'PUT',
6633                                        path_params,
6634                                        query_params,
6635                                        header_params,
6636                                        body=body_params,
6637                                        post_params=form_params,
6638                                        files=local_var_files,
6639                                        response_type='ENoteConfiguration',
6640                                        auth_settings=auth_settings,
6641                                        callback=params.get('callback'),
6642                                        _return_http_data_only=params.get('_return_http_data_only'),
6643                                        _preload_content=params.get('_preload_content', True),
6644                                        _request_timeout=params.get('_request_timeout'),
6645                                        collection_formats=collection_formats)
6646
6647    def update_envelope_purge_configuration(self, account_id, **kwargs):
6648        """
6649        Updates envelope purge configuration.
6650        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6651        This method makes a synchronous HTTP request by default. To make an
6652        asynchronous HTTP request, please define a `callback` function
6653        to be invoked when receiving the response.
6654        >>> def callback_function(response):
6655        >>>     pprint(response)
6656        >>>
6657        >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function)
6658
6659        :param callback function: The callback function
6660            for asynchronous request. (optional)
6661        :param str account_id: The external account number (int) or account ID Guid. (required)
6662        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6663        :return: EnvelopePurgeConfiguration
6664                 If the method is called asynchronously,
6665                 returns the request thread.
6666        """
6667        kwargs['_return_http_data_only'] = True
6668        if kwargs.get('callback'):
6669            return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6670        else:
6671            (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6672            return data
6673
6674    def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
6675        """
6676        Updates envelope purge configuration.
6677        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6678        This method makes a synchronous HTTP request by default. To make an
6679        asynchronous HTTP request, please define a `callback` function
6680        to be invoked when receiving the response.
6681        >>> def callback_function(response):
6682        >>>     pprint(response)
6683        >>>
6684        >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
6685
6686        :param callback function: The callback function
6687            for asynchronous request. (optional)
6688        :param str account_id: The external account number (int) or account ID Guid. (required)
6689        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6690        :return: EnvelopePurgeConfiguration
6691                 If the method is called asynchronously,
6692                 returns the request thread.
6693        """
6694
6695        all_params = ['account_id', 'envelope_purge_configuration']
6696        all_params.append('callback')
6697        all_params.append('_return_http_data_only')
6698        all_params.append('_preload_content')
6699        all_params.append('_request_timeout')
6700
6701        params = locals()
6702        for key, val in iteritems(params['kwargs']):
6703            if key not in all_params:
6704                raise TypeError(
6705                    "Got an unexpected keyword argument '%s'"
6706                    " to method update_envelope_purge_configuration" % key
6707                )
6708            params[key] = val
6709        del params['kwargs']
6710        # verify the required parameter 'account_id' is set
6711        if ('account_id' not in params) or (params['account_id'] is None):
6712            raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`")
6713
6714
6715        collection_formats = {}
6716
6717        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
6718        path_params = {}
6719        if 'account_id' in params:
6720            path_params['accountId'] = params['account_id']
6721
6722        query_params = {}
6723
6724        header_params = {}
6725
6726        form_params = []
6727        local_var_files = {}
6728
6729        body_params = None
6730        if 'envelope_purge_configuration' in params:
6731            body_params = params['envelope_purge_configuration']
6732        # HTTP header `Accept`
6733        header_params['Accept'] = self.api_client.\
6734            select_header_accept(['application/json'])
6735
6736        # Authentication setting
6737        auth_settings = []
6738
6739        return self.api_client.call_api(resource_path, 'PUT',
6740                                        path_params,
6741                                        query_params,
6742                                        header_params,
6743                                        body=body_params,
6744                                        post_params=form_params,
6745                                        files=local_var_files,
6746                                        response_type='EnvelopePurgeConfiguration',
6747                                        auth_settings=auth_settings,
6748                                        callback=params.get('callback'),
6749                                        _return_http_data_only=params.get('_return_http_data_only'),
6750                                        _preload_content=params.get('_preload_content', True),
6751                                        _request_timeout=params.get('_request_timeout'),
6752                                        collection_formats=collection_formats)
6753
6754    def update_favorite_template(self, account_id, **kwargs):
6755        """
6756        Favorites a template
6757        
6758        This method makes a synchronous HTTP request by default. To make an
6759        asynchronous HTTP request, please define a `callback` function
6760        to be invoked when receiving the response.
6761        >>> def callback_function(response):
6762        >>>     pprint(response)
6763        >>>
6764        >>> thread = api.update_favorite_template(account_id, callback=callback_function)
6765
6766        :param callback function: The callback function
6767            for asynchronous request. (optional)
6768        :param str account_id: The external account number (int) or account ID Guid. (required)
6769        :param FavoriteTemplatesInfo favorite_templates_info:
6770        :return: FavoriteTemplatesInfo
6771                 If the method is called asynchronously,
6772                 returns the request thread.
6773        """
6774        kwargs['_return_http_data_only'] = True
6775        if kwargs.get('callback'):
6776            return self.update_favorite_template_with_http_info(account_id, **kwargs)
6777        else:
6778            (data) = self.update_favorite_template_with_http_info(account_id, **kwargs)
6779            return data
6780
6781    def update_favorite_template_with_http_info(self, account_id, **kwargs):
6782        """
6783        Favorites a template
6784        
6785        This method makes a synchronous HTTP request by default. To make an
6786        asynchronous HTTP request, please define a `callback` function
6787        to be invoked when receiving the response.
6788        >>> def callback_function(response):
6789        >>>     pprint(response)
6790        >>>
6791        >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function)
6792
6793        :param callback function: The callback function
6794            for asynchronous request. (optional)
6795        :param str account_id: The external account number (int) or account ID Guid. (required)
6796        :param FavoriteTemplatesInfo favorite_templates_info:
6797        :return: FavoriteTemplatesInfo
6798                 If the method is called asynchronously,
6799                 returns the request thread.
6800        """
6801
6802        all_params = ['account_id', 'favorite_templates_info']
6803        all_params.append('callback')
6804        all_params.append('_return_http_data_only')
6805        all_params.append('_preload_content')
6806        all_params.append('_request_timeout')
6807
6808        params = locals()
6809        for key, val in iteritems(params['kwargs']):
6810            if key not in all_params:
6811                raise TypeError(
6812                    "Got an unexpected keyword argument '%s'"
6813                    " to method update_favorite_template" % key
6814                )
6815            params[key] = val
6816        del params['kwargs']
6817        # verify the required parameter 'account_id' is set
6818        if ('account_id' not in params) or (params['account_id'] is None):
6819            raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`")
6820
6821
6822        collection_formats = {}
6823
6824        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
6825        path_params = {}
6826        if 'account_id' in params:
6827            path_params['accountId'] = params['account_id']
6828
6829        query_params = {}
6830
6831        header_params = {}
6832
6833        form_params = []
6834        local_var_files = {}
6835
6836        body_params = None
6837        if 'favorite_templates_info' in params:
6838            body_params = params['favorite_templates_info']
6839        # HTTP header `Accept`
6840        header_params['Accept'] = self.api_client.\
6841            select_header_accept(['application/json'])
6842
6843        # Authentication setting
6844        auth_settings = []
6845
6846        return self.api_client.call_api(resource_path, 'PUT',
6847                                        path_params,
6848                                        query_params,
6849                                        header_params,
6850                                        body=body_params,
6851                                        post_params=form_params,
6852                                        files=local_var_files,
6853                                        response_type='FavoriteTemplatesInfo',
6854                                        auth_settings=auth_settings,
6855                                        callback=params.get('callback'),
6856                                        _return_http_data_only=params.get('_return_http_data_only'),
6857                                        _preload_content=params.get('_preload_content', True),
6858                                        _request_timeout=params.get('_request_timeout'),
6859                                        collection_formats=collection_formats)
6860
6861    def update_notification_defaults(self, account_id, **kwargs):
6862        """
6863        Updates default user level settings for a specified account
6864        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6865        This method makes a synchronous HTTP request by default. To make an
6866        asynchronous HTTP request, please define a `callback` function
6867        to be invoked when receiving the response.
6868        >>> def callback_function(response):
6869        >>>     pprint(response)
6870        >>>
6871        >>> thread = api.update_notification_defaults(account_id, callback=callback_function)
6872
6873        :param callback function: The callback function
6874            for asynchronous request. (optional)
6875        :param str account_id: The external account number (int) or account ID Guid. (required)
6876        :param NotificationDefaults notification_defaults:
6877        :return: NotificationDefaults
6878                 If the method is called asynchronously,
6879                 returns the request thread.
6880        """
6881        kwargs['_return_http_data_only'] = True
6882        if kwargs.get('callback'):
6883            return self.update_notification_defaults_with_http_info(account_id, **kwargs)
6884        else:
6885            (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs)
6886            return data
6887
6888    def update_notification_defaults_with_http_info(self, account_id, **kwargs):
6889        """
6890        Updates default user level settings for a specified account
6891        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6892        This method makes a synchronous HTTP request by default. To make an
6893        asynchronous HTTP request, please define a `callback` function
6894        to be invoked when receiving the response.
6895        >>> def callback_function(response):
6896        >>>     pprint(response)
6897        >>>
6898        >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function)
6899
6900        :param callback function: The callback function
6901            for asynchronous request. (optional)
6902        :param str account_id: The external account number (int) or account ID Guid. (required)
6903        :param NotificationDefaults notification_defaults:
6904        :return: NotificationDefaults
6905                 If the method is called asynchronously,
6906                 returns the request thread.
6907        """
6908
6909        all_params = ['account_id', 'notification_defaults']
6910        all_params.append('callback')
6911        all_params.append('_return_http_data_only')
6912        all_params.append('_preload_content')
6913        all_params.append('_request_timeout')
6914
6915        params = locals()
6916        for key, val in iteritems(params['kwargs']):
6917            if key not in all_params:
6918                raise TypeError(
6919                    "Got an unexpected keyword argument '%s'"
6920                    " to method update_notification_defaults" % key
6921                )
6922            params[key] = val
6923        del params['kwargs']
6924        # verify the required parameter 'account_id' is set
6925        if ('account_id' not in params) or (params['account_id'] is None):
6926            raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`")
6927
6928
6929        collection_formats = {}
6930
6931        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
6932        path_params = {}
6933        if 'account_id' in params:
6934            path_params['accountId'] = params['account_id']
6935
6936        query_params = {}
6937
6938        header_params = {}
6939
6940        form_params = []
6941        local_var_files = {}
6942
6943        body_params = None
6944        if 'notification_defaults' in params:
6945            body_params = params['notification_defaults']
6946        # HTTP header `Accept`
6947        header_params['Accept'] = self.api_client.\
6948            select_header_accept(['application/json'])
6949
6950        # Authentication setting
6951        auth_settings = []
6952
6953        return self.api_client.call_api(resource_path, 'PUT',
6954                                        path_params,
6955                                        query_params,
6956                                        header_params,
6957                                        body=body_params,
6958                                        post_params=form_params,
6959                                        files=local_var_files,
6960                                        response_type='NotificationDefaults',
6961                                        auth_settings=auth_settings,
6962                                        callback=params.get('callback'),
6963                                        _return_http_data_only=params.get('_return_http_data_only'),
6964                                        _preload_content=params.get('_preload_content', True),
6965                                        _request_timeout=params.get('_request_timeout'),
6966                                        collection_formats=collection_formats)
6967
6968    def update_password_rules(self, account_id, **kwargs):
6969        """
6970        Update the password rules
6971        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
6972        This method makes a synchronous HTTP request by default. To make an
6973        asynchronous HTTP request, please define a `callback` function
6974        to be invoked when receiving the response.
6975        >>> def callback_function(response):
6976        >>>     pprint(response)
6977        >>>
6978        >>> thread = api.update_password_rules(account_id, callback=callback_function)
6979
6980        :param callback function: The callback function
6981            for asynchronous request. (optional)
6982        :param str account_id: The external account number (int) or account ID Guid. (required)
6983        :param AccountPasswordRules account_password_rules:
6984        :return: AccountPasswordRules
6985                 If the method is called asynchronously,
6986                 returns the request thread.
6987        """
6988        kwargs['_return_http_data_only'] = True
6989        if kwargs.get('callback'):
6990            return self.update_password_rules_with_http_info(account_id, **kwargs)
6991        else:
6992            (data) = self.update_password_rules_with_http_info(account_id, **kwargs)
6993            return data
6994
6995    def update_password_rules_with_http_info(self, account_id, **kwargs):
6996        """
6997        Update the password rules
6998        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
6999        This method makes a synchronous HTTP request by default. To make an
7000        asynchronous HTTP request, please define a `callback` function
7001        to be invoked when receiving the response.
7002        >>> def callback_function(response):
7003        >>>     pprint(response)
7004        >>>
7005        >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function)
7006
7007        :param callback function: The callback function
7008            for asynchronous request. (optional)
7009        :param str account_id: The external account number (int) or account ID Guid. (required)
7010        :param AccountPasswordRules account_password_rules:
7011        :return: AccountPasswordRules
7012                 If the method is called asynchronously,
7013                 returns the request thread.
7014        """
7015
7016        all_params = ['account_id', 'account_password_rules']
7017        all_params.append('callback')
7018        all_params.append('_return_http_data_only')
7019        all_params.append('_preload_content')
7020        all_params.append('_request_timeout')
7021
7022        params = locals()
7023        for key, val in iteritems(params['kwargs']):
7024            if key not in all_params:
7025                raise TypeError(
7026                    "Got an unexpected keyword argument '%s'"
7027                    " to method update_password_rules" % key
7028                )
7029            params[key] = val
7030        del params['kwargs']
7031        # verify the required parameter 'account_id' is set
7032        if ('account_id' not in params) or (params['account_id'] is None):
7033            raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`")
7034
7035
7036        collection_formats = {}
7037
7038        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
7039        path_params = {}
7040        if 'account_id' in params:
7041            path_params['accountId'] = params['account_id']
7042
7043        query_params = {}
7044
7045        header_params = {}
7046
7047        form_params = []
7048        local_var_files = {}
7049
7050        body_params = None
7051        if 'account_password_rules' in params:
7052            body_params = params['account_password_rules']
7053        # HTTP header `Accept`
7054        header_params['Accept'] = self.api_client.\
7055            select_header_accept(['application/json'])
7056
7057        # Authentication setting
7058        auth_settings = []
7059
7060        return self.api_client.call_api(resource_path, 'PUT',
7061                                        path_params,
7062                                        query_params,
7063                                        header_params,
7064                                        body=body_params,
7065                                        post_params=form_params,
7066                                        files=local_var_files,
7067                                        response_type='AccountPasswordRules',
7068                                        auth_settings=auth_settings,
7069                                        callback=params.get('callback'),
7070                                        _return_http_data_only=params.get('_return_http_data_only'),
7071                                        _preload_content=params.get('_preload_content', True),
7072                                        _request_timeout=params.get('_request_timeout'),
7073                                        collection_formats=collection_formats)
7074
7075    def update_permission_profile(self, account_id, permission_profile_id, **kwargs):
7076        """
7077        Updates a permission profile within the specified account.
7078        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7079        This method makes a synchronous HTTP request by default. To make an
7080        asynchronous HTTP request, please define a `callback` function
7081        to be invoked when receiving the response.
7082        >>> def callback_function(response):
7083        >>>     pprint(response)
7084        >>>
7085        >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function)
7086
7087        :param callback function: The callback function
7088            for asynchronous request. (optional)
7089        :param str account_id: The external account number (int) or account ID Guid. (required)
7090        :param str permission_profile_id: (required)
7091        :param str include:
7092        :param PermissionProfile permission_profile:
7093        :return: PermissionProfile
7094                 If the method is called asynchronously,
7095                 returns the request thread.
7096        """
7097        kwargs['_return_http_data_only'] = True
7098        if kwargs.get('callback'):
7099            return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7100        else:
7101            (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7102            return data
7103
7104    def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
7105        """
7106        Updates a permission profile within the specified account.
7107        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7108        This method makes a synchronous HTTP request by default. To make an
7109        asynchronous HTTP request, please define a `callback` function
7110        to be invoked when receiving the response.
7111        >>> def callback_function(response):
7112        >>>     pprint(response)
7113        >>>
7114        >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
7115
7116        :param callback function: The callback function
7117            for asynchronous request. (optional)
7118        :param str account_id: The external account number (int) or account ID Guid. (required)
7119        :param str permission_profile_id: (required)
7120        :param str include:
7121        :param PermissionProfile permission_profile:
7122        :return: PermissionProfile
7123                 If the method is called asynchronously,
7124                 returns the request thread.
7125        """
7126
7127        all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile']
7128        all_params.append('callback')
7129        all_params.append('_return_http_data_only')
7130        all_params.append('_preload_content')
7131        all_params.append('_request_timeout')
7132
7133        params = locals()
7134        for key, val in iteritems(params['kwargs']):
7135            if key not in all_params:
7136                raise TypeError(
7137                    "Got an unexpected keyword argument '%s'"
7138                    " to method update_permission_profile" % key
7139                )
7140            params[key] = val
7141        del params['kwargs']
7142        # verify the required parameter 'account_id' is set
7143        if ('account_id' not in params) or (params['account_id'] is None):
7144            raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`")
7145        # verify the required parameter 'permission_profile_id' is set
7146        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
7147            raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`")
7148
7149
7150        collection_formats = {}
7151
7152        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
7153        path_params = {}
7154        if 'account_id' in params:
7155            path_params['accountId'] = params['account_id']
7156        if 'permission_profile_id' in params:
7157            path_params['permissionProfileId'] = params['permission_profile_id']
7158
7159        query_params = {}
7160        if 'include' in params:
7161            query_params['include'] = params['include']
7162
7163        header_params = {}
7164
7165        form_params = []
7166        local_var_files = {}
7167
7168        body_params = None
7169        if 'permission_profile' in params:
7170            body_params = params['permission_profile']
7171        # HTTP header `Accept`
7172        header_params['Accept'] = self.api_client.\
7173            select_header_accept(['application/json'])
7174
7175        # Authentication setting
7176        auth_settings = []
7177
7178        return self.api_client.call_api(resource_path, 'PUT',
7179                                        path_params,
7180                                        query_params,
7181                                        header_params,
7182                                        body=body_params,
7183                                        post_params=form_params,
7184                                        files=local_var_files,
7185                                        response_type='PermissionProfile',
7186                                        auth_settings=auth_settings,
7187                                        callback=params.get('callback'),
7188                                        _return_http_data_only=params.get('_return_http_data_only'),
7189                                        _preload_content=params.get('_preload_content', True),
7190                                        _request_timeout=params.get('_request_timeout'),
7191                                        collection_formats=collection_formats)
7192
7193    def update_settings(self, account_id, **kwargs):
7194        """
7195        Updates the account settings for an account.
7196        Updates the account settings for the specified account.
7197        This method makes a synchronous HTTP request by default. To make an
7198        asynchronous HTTP request, please define a `callback` function
7199        to be invoked when receiving the response.
7200        >>> def callback_function(response):
7201        >>>     pprint(response)
7202        >>>
7203        >>> thread = api.update_settings(account_id, callback=callback_function)
7204
7205        :param callback function: The callback function
7206            for asynchronous request. (optional)
7207        :param str account_id: The external account number (int) or account ID Guid. (required)
7208        :param AccountSettingsInformation account_settings_information:
7209        :return: None
7210                 If the method is called asynchronously,
7211                 returns the request thread.
7212        """
7213        kwargs['_return_http_data_only'] = True
7214        if kwargs.get('callback'):
7215            return self.update_settings_with_http_info(account_id, **kwargs)
7216        else:
7217            (data) = self.update_settings_with_http_info(account_id, **kwargs)
7218            return data
7219
7220    def update_settings_with_http_info(self, account_id, **kwargs):
7221        """
7222        Updates the account settings for an account.
7223        Updates the account settings for the specified account.
7224        This method makes a synchronous HTTP request by default. To make an
7225        asynchronous HTTP request, please define a `callback` function
7226        to be invoked when receiving the response.
7227        >>> def callback_function(response):
7228        >>>     pprint(response)
7229        >>>
7230        >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function)
7231
7232        :param callback function: The callback function
7233            for asynchronous request. (optional)
7234        :param str account_id: The external account number (int) or account ID Guid. (required)
7235        :param AccountSettingsInformation account_settings_information:
7236        :return: None
7237                 If the method is called asynchronously,
7238                 returns the request thread.
7239        """
7240
7241        all_params = ['account_id', 'account_settings_information']
7242        all_params.append('callback')
7243        all_params.append('_return_http_data_only')
7244        all_params.append('_preload_content')
7245        all_params.append('_request_timeout')
7246
7247        params = locals()
7248        for key, val in iteritems(params['kwargs']):
7249            if key not in all_params:
7250                raise TypeError(
7251                    "Got an unexpected keyword argument '%s'"
7252                    " to method update_settings" % key
7253                )
7254            params[key] = val
7255        del params['kwargs']
7256        # verify the required parameter 'account_id' is set
7257        if ('account_id' not in params) or (params['account_id'] is None):
7258            raise ValueError("Missing the required parameter `account_id` when calling `update_settings`")
7259
7260
7261        collection_formats = {}
7262
7263        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
7264        path_params = {}
7265        if 'account_id' in params:
7266            path_params['accountId'] = params['account_id']
7267
7268        query_params = {}
7269
7270        header_params = {}
7271
7272        form_params = []
7273        local_var_files = {}
7274
7275        body_params = None
7276        if 'account_settings_information' in params:
7277            body_params = params['account_settings_information']
7278        # HTTP header `Accept`
7279        header_params['Accept'] = self.api_client.\
7280            select_header_accept(['application/json'])
7281
7282        # Authentication setting
7283        auth_settings = []
7284
7285        return self.api_client.call_api(resource_path, 'PUT',
7286                                        path_params,
7287                                        query_params,
7288                                        header_params,
7289                                        body=body_params,
7290                                        post_params=form_params,
7291                                        files=local_var_files,
7292                                        response_type=None,
7293                                        auth_settings=auth_settings,
7294                                        callback=params.get('callback'),
7295                                        _return_http_data_only=params.get('_return_http_data_only'),
7296                                        _preload_content=params.get('_preload_content', True),
7297                                        _request_timeout=params.get('_request_timeout'),
7298                                        collection_formats=collection_formats)
7299
7300    def update_shared_access(self, account_id, **kwargs):
7301        """
7302        Reserved: Sets the shared access information for users.
7303        Reserved: Sets the shared access information for one or more users.
7304        This method makes a synchronous HTTP request by default. To make an
7305        asynchronous HTTP request, please define a `callback` function
7306        to be invoked when receiving the response.
7307        >>> def callback_function(response):
7308        >>>     pprint(response)
7309        >>>
7310        >>> thread = api.update_shared_access(account_id, callback=callback_function)
7311
7312        :param callback function: The callback function
7313            for asynchronous request. (optional)
7314        :param str account_id: The external account number (int) or account ID Guid. (required)
7315        :param str item_type:
7316        :param str preserve_existing_shared_access:
7317        :param str user_ids:
7318        :param AccountSharedAccess account_shared_access:
7319        :return: AccountSharedAccess
7320                 If the method is called asynchronously,
7321                 returns the request thread.
7322        """
7323        kwargs['_return_http_data_only'] = True
7324        if kwargs.get('callback'):
7325            return self.update_shared_access_with_http_info(account_id, **kwargs)
7326        else:
7327            (data) = self.update_shared_access_with_http_info(account_id, **kwargs)
7328            return data
7329
7330    def update_shared_access_with_http_info(self, account_id, **kwargs):
7331        """
7332        Reserved: Sets the shared access information for users.
7333        Reserved: Sets the shared access information for one or more users.
7334        This method makes a synchronous HTTP request by default. To make an
7335        asynchronous HTTP request, please define a `callback` function
7336        to be invoked when receiving the response.
7337        >>> def callback_function(response):
7338        >>>     pprint(response)
7339        >>>
7340        >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function)
7341
7342        :param callback function: The callback function
7343            for asynchronous request. (optional)
7344        :param str account_id: The external account number (int) or account ID Guid. (required)
7345        :param str item_type:
7346        :param str preserve_existing_shared_access:
7347        :param str user_ids:
7348        :param AccountSharedAccess account_shared_access:
7349        :return: AccountSharedAccess
7350                 If the method is called asynchronously,
7351                 returns the request thread.
7352        """
7353
7354        all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access']
7355        all_params.append('callback')
7356        all_params.append('_return_http_data_only')
7357        all_params.append('_preload_content')
7358        all_params.append('_request_timeout')
7359
7360        params = locals()
7361        for key, val in iteritems(params['kwargs']):
7362            if key not in all_params:
7363                raise TypeError(
7364                    "Got an unexpected keyword argument '%s'"
7365                    " to method update_shared_access" % key
7366                )
7367            params[key] = val
7368        del params['kwargs']
7369        # verify the required parameter 'account_id' is set
7370        if ('account_id' not in params) or (params['account_id'] is None):
7371            raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`")
7372
7373
7374        collection_formats = {}
7375
7376        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
7377        path_params = {}
7378        if 'account_id' in params:
7379            path_params['accountId'] = params['account_id']
7380
7381        query_params = {}
7382        if 'item_type' in params:
7383            query_params['item_type'] = params['item_type']
7384        if 'preserve_existing_shared_access' in params:
7385            query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access']
7386        if 'user_ids' in params:
7387            query_params['user_ids'] = params['user_ids']
7388
7389        header_params = {}
7390
7391        form_params = []
7392        local_var_files = {}
7393
7394        body_params = None
7395        if 'account_shared_access' in params:
7396            body_params = params['account_shared_access']
7397        # HTTP header `Accept`
7398        header_params['Accept'] = self.api_client.\
7399            select_header_accept(['application/json'])
7400
7401        # Authentication setting
7402        auth_settings = []
7403
7404        return self.api_client.call_api(resource_path, 'PUT',
7405                                        path_params,
7406                                        query_params,
7407                                        header_params,
7408                                        body=body_params,
7409                                        post_params=form_params,
7410                                        files=local_var_files,
7411                                        response_type='AccountSharedAccess',
7412                                        auth_settings=auth_settings,
7413                                        callback=params.get('callback'),
7414                                        _return_http_data_only=params.get('_return_http_data_only'),
7415                                        _preload_content=params.get('_preload_content', True),
7416                                        _request_timeout=params.get('_request_timeout'),
7417                                        collection_formats=collection_formats)
7418
7419    def update_watermark(self, account_id, **kwargs):
7420        """
7421        Update watermark information.
7422        
7423        This method makes a synchronous HTTP request by default. To make an
7424        asynchronous HTTP request, please define a `callback` function
7425        to be invoked when receiving the response.
7426        >>> def callback_function(response):
7427        >>>     pprint(response)
7428        >>>
7429        >>> thread = api.update_watermark(account_id, callback=callback_function)
7430
7431        :param callback function: The callback function
7432            for asynchronous request. (optional)
7433        :param str account_id: The external account number (int) or account ID Guid. (required)
7434        :param Watermark watermark:
7435        :return: Watermark
7436                 If the method is called asynchronously,
7437                 returns the request thread.
7438        """
7439        kwargs['_return_http_data_only'] = True
7440        if kwargs.get('callback'):
7441            return self.update_watermark_with_http_info(account_id, **kwargs)
7442        else:
7443            (data) = self.update_watermark_with_http_info(account_id, **kwargs)
7444            return data
7445
7446    def update_watermark_with_http_info(self, account_id, **kwargs):
7447        """
7448        Update watermark information.
7449        
7450        This method makes a synchronous HTTP request by default. To make an
7451        asynchronous HTTP request, please define a `callback` function
7452        to be invoked when receiving the response.
7453        >>> def callback_function(response):
7454        >>>     pprint(response)
7455        >>>
7456        >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function)
7457
7458        :param callback function: The callback function
7459            for asynchronous request. (optional)
7460        :param str account_id: The external account number (int) or account ID Guid. (required)
7461        :param Watermark watermark:
7462        :return: Watermark
7463                 If the method is called asynchronously,
7464                 returns the request thread.
7465        """
7466
7467        all_params = ['account_id', 'watermark']
7468        all_params.append('callback')
7469        all_params.append('_return_http_data_only')
7470        all_params.append('_preload_content')
7471        all_params.append('_request_timeout')
7472
7473        params = locals()
7474        for key, val in iteritems(params['kwargs']):
7475            if key not in all_params:
7476                raise TypeError(
7477                    "Got an unexpected keyword argument '%s'"
7478                    " to method update_watermark" % key
7479                )
7480            params[key] = val
7481        del params['kwargs']
7482        # verify the required parameter 'account_id' is set
7483        if ('account_id' not in params) or (params['account_id'] is None):
7484            raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`")
7485
7486
7487        collection_formats = {}
7488
7489        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
7490        path_params = {}
7491        if 'account_id' in params:
7492            path_params['accountId'] = params['account_id']
7493
7494        query_params = {}
7495
7496        header_params = {}
7497
7498        form_params = []
7499        local_var_files = {}
7500
7501        body_params = None
7502        if 'watermark' in params:
7503            body_params = params['watermark']
7504        # HTTP header `Accept`
7505        header_params['Accept'] = self.api_client.\
7506            select_header_accept(['application/json'])
7507
7508        # Authentication setting
7509        auth_settings = []
7510
7511        return self.api_client.call_api(resource_path, 'PUT',
7512                                        path_params,
7513                                        query_params,
7514                                        header_params,
7515                                        body=body_params,
7516                                        post_params=form_params,
7517                                        files=local_var_files,
7518                                        response_type='Watermark',
7519                                        auth_settings=auth_settings,
7520                                        callback=params.get('callback'),
7521                                        _return_http_data_only=params.get('_return_http_data_only'),
7522                                        _preload_content=params.get('_preload_content', True),
7523                                        _request_timeout=params.get('_request_timeout'),
7524                                        collection_formats=collection_formats)
class AccountsApi:
  28class AccountsApi(object):
  29    """
  30    NOTE: This class is auto generated by the swagger code generator program.
  31    Do not edit the class manually.
  32    Ref: https://github.com/swagger-api/swagger-codegen
  33    """
  34
  35    def __init__(self, api_client=None):
  36        config = Configuration()
  37        if api_client:
  38            self.api_client = api_client
  39        else:
  40            if not config.api_client:
  41                config.api_client = ApiClient()
  42            self.api_client = config.api_client
  43
  44    def create(self, **kwargs):
  45        """
  46        Creates new accounts.
  47        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
  48        This method makes a synchronous HTTP request by default. To make an
  49        asynchronous HTTP request, please define a `callback` function
  50        to be invoked when receiving the response.
  51        >>> def callback_function(response):
  52        >>>     pprint(response)
  53        >>>
  54        >>> thread = api.create(callback=callback_function)
  55
  56        :param callback function: The callback function
  57            for asynchronous request. (optional)
  58        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
  59        :param NewAccountDefinition new_account_definition:
  60        :return: NewAccountSummary
  61                 If the method is called asynchronously,
  62                 returns the request thread.
  63        """
  64        kwargs['_return_http_data_only'] = True
  65        if kwargs.get('callback'):
  66            return self.create_with_http_info(**kwargs)
  67        else:
  68            (data) = self.create_with_http_info(**kwargs)
  69            return data
  70
  71    def create_with_http_info(self, **kwargs):
  72        """
  73        Creates new accounts.
  74        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
  75        This method makes a synchronous HTTP request by default. To make an
  76        asynchronous HTTP request, please define a `callback` function
  77        to be invoked when receiving the response.
  78        >>> def callback_function(response):
  79        >>>     pprint(response)
  80        >>>
  81        >>> thread = api.create_with_http_info(callback=callback_function)
  82
  83        :param callback function: The callback function
  84            for asynchronous request. (optional)
  85        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
  86        :param NewAccountDefinition new_account_definition:
  87        :return: NewAccountSummary
  88                 If the method is called asynchronously,
  89                 returns the request thread.
  90        """
  91
  92        all_params = ['preview_billing_plan', 'new_account_definition']
  93        all_params.append('callback')
  94        all_params.append('_return_http_data_only')
  95        all_params.append('_preload_content')
  96        all_params.append('_request_timeout')
  97
  98        params = locals()
  99        for key, val in iteritems(params['kwargs']):
 100            if key not in all_params:
 101                raise TypeError(
 102                    "Got an unexpected keyword argument '%s'"
 103                    " to method create" % key
 104                )
 105            params[key] = val
 106        del params['kwargs']
 107
 108
 109        collection_formats = {}
 110
 111        resource_path = '/v2.1/accounts'.replace('{format}', 'json')
 112        path_params = {}
 113
 114        query_params = {}
 115        if 'preview_billing_plan' in params:
 116            query_params['preview_billing_plan'] = params['preview_billing_plan']
 117
 118        header_params = {}
 119
 120        form_params = []
 121        local_var_files = {}
 122
 123        body_params = None
 124        if 'new_account_definition' in params:
 125            body_params = params['new_account_definition']
 126        # HTTP header `Accept`
 127        header_params['Accept'] = self.api_client.\
 128            select_header_accept(['application/json'])
 129
 130        # Authentication setting
 131        auth_settings = []
 132
 133        return self.api_client.call_api(resource_path, 'POST',
 134                                        path_params,
 135                                        query_params,
 136                                        header_params,
 137                                        body=body_params,
 138                                        post_params=form_params,
 139                                        files=local_var_files,
 140                                        response_type='NewAccountSummary',
 141                                        auth_settings=auth_settings,
 142                                        callback=params.get('callback'),
 143                                        _return_http_data_only=params.get('_return_http_data_only'),
 144                                        _preload_content=params.get('_preload_content', True),
 145                                        _request_timeout=params.get('_request_timeout'),
 146                                        collection_formats=collection_formats)
 147
 148    def create_account_signatures(self, account_id, **kwargs):
 149        """
 150        Adds/updates one or more account signatures. This request may include images in multi-part format.
 151        
 152        This method makes a synchronous HTTP request by default. To make an
 153        asynchronous HTTP request, please define a `callback` function
 154        to be invoked when receiving the response.
 155        >>> def callback_function(response):
 156        >>>     pprint(response)
 157        >>>
 158        >>> thread = api.create_account_signatures(account_id, callback=callback_function)
 159
 160        :param callback function: The callback function
 161            for asynchronous request. (optional)
 162        :param str account_id: The external account number (int) or account ID Guid. (required)
 163        :param str decode_only:
 164        :param AccountSignaturesInformation account_signatures_information:
 165        :return: AccountSignaturesInformation
 166                 If the method is called asynchronously,
 167                 returns the request thread.
 168        """
 169        kwargs['_return_http_data_only'] = True
 170        if kwargs.get('callback'):
 171            return self.create_account_signatures_with_http_info(account_id, **kwargs)
 172        else:
 173            (data) = self.create_account_signatures_with_http_info(account_id, **kwargs)
 174            return data
 175
 176    def create_account_signatures_with_http_info(self, account_id, **kwargs):
 177        """
 178        Adds/updates one or more account signatures. This request may include images in multi-part format.
 179        
 180        This method makes a synchronous HTTP request by default. To make an
 181        asynchronous HTTP request, please define a `callback` function
 182        to be invoked when receiving the response.
 183        >>> def callback_function(response):
 184        >>>     pprint(response)
 185        >>>
 186        >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function)
 187
 188        :param callback function: The callback function
 189            for asynchronous request. (optional)
 190        :param str account_id: The external account number (int) or account ID Guid. (required)
 191        :param str decode_only:
 192        :param AccountSignaturesInformation account_signatures_information:
 193        :return: AccountSignaturesInformation
 194                 If the method is called asynchronously,
 195                 returns the request thread.
 196        """
 197
 198        all_params = ['account_id', 'decode_only', 'account_signatures_information']
 199        all_params.append('callback')
 200        all_params.append('_return_http_data_only')
 201        all_params.append('_preload_content')
 202        all_params.append('_request_timeout')
 203
 204        params = locals()
 205        for key, val in iteritems(params['kwargs']):
 206            if key not in all_params:
 207                raise TypeError(
 208                    "Got an unexpected keyword argument '%s'"
 209                    " to method create_account_signatures" % key
 210                )
 211            params[key] = val
 212        del params['kwargs']
 213        # verify the required parameter 'account_id' is set
 214        if ('account_id' not in params) or (params['account_id'] is None):
 215            raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`")
 216
 217
 218        collection_formats = {}
 219
 220        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
 221        path_params = {}
 222        if 'account_id' in params:
 223            path_params['accountId'] = params['account_id']
 224
 225        query_params = {}
 226        if 'decode_only' in params:
 227            query_params['decode_only'] = params['decode_only']
 228
 229        header_params = {}
 230
 231        form_params = []
 232        local_var_files = {}
 233
 234        body_params = None
 235        if 'account_signatures_information' in params:
 236            body_params = params['account_signatures_information']
 237        # HTTP header `Accept`
 238        header_params['Accept'] = self.api_client.\
 239            select_header_accept(['application/json'])
 240
 241        # Authentication setting
 242        auth_settings = []
 243
 244        return self.api_client.call_api(resource_path, 'POST',
 245                                        path_params,
 246                                        query_params,
 247                                        header_params,
 248                                        body=body_params,
 249                                        post_params=form_params,
 250                                        files=local_var_files,
 251                                        response_type='AccountSignaturesInformation',
 252                                        auth_settings=auth_settings,
 253                                        callback=params.get('callback'),
 254                                        _return_http_data_only=params.get('_return_http_data_only'),
 255                                        _preload_content=params.get('_preload_content', True),
 256                                        _request_timeout=params.get('_request_timeout'),
 257                                        collection_formats=collection_formats)
 258
 259    def create_brand(self, account_id, **kwargs):
 260        """
 261        Creates one or more brand profile files for the account.
 262        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
 263        This method makes a synchronous HTTP request by default. To make an
 264        asynchronous HTTP request, please define a `callback` function
 265        to be invoked when receiving the response.
 266        >>> def callback_function(response):
 267        >>>     pprint(response)
 268        >>>
 269        >>> thread = api.create_brand(account_id, callback=callback_function)
 270
 271        :param callback function: The callback function
 272            for asynchronous request. (optional)
 273        :param str account_id: The external account number (int) or account ID GUID. (required)
 274        :param Brand brand: 
 275        :return: BrandsResponse
 276                 If the method is called asynchronously,
 277                 returns the request thread.
 278        """
 279        kwargs['_return_http_data_only'] = True
 280        if kwargs.get('callback'):
 281            return self.create_brand_with_http_info(account_id, **kwargs)
 282        else:
 283            (data) = self.create_brand_with_http_info(account_id, **kwargs)
 284            return data
 285
 286    def create_brand_with_http_info(self, account_id, **kwargs):
 287        """
 288        Creates one or more brand profile files for the account.
 289        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
 290        This method makes a synchronous HTTP request by default. To make an
 291        asynchronous HTTP request, please define a `callback` function
 292        to be invoked when receiving the response.
 293        >>> def callback_function(response):
 294        >>>     pprint(response)
 295        >>>
 296        >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function)
 297
 298        :param callback function: The callback function
 299            for asynchronous request. (optional)
 300        :param str account_id: The external account number (int) or account ID GUID. (required)
 301        :param Brand brand: 
 302        :return: BrandsResponse
 303                 If the method is called asynchronously,
 304                 returns the request thread.
 305        """
 306
 307        all_params = ['account_id', 'brand']
 308        all_params.append('callback')
 309        all_params.append('_return_http_data_only')
 310        all_params.append('_preload_content')
 311        all_params.append('_request_timeout')
 312
 313        params = locals()
 314        for key, val in iteritems(params['kwargs']):
 315            if key not in all_params:
 316                raise TypeError(
 317                    "Got an unexpected keyword argument '%s'"
 318                    " to method create_brand" % key
 319                )
 320            params[key] = val
 321        del params['kwargs']
 322        # verify the required parameter 'account_id' is set
 323        if ('account_id' not in params) or (params['account_id'] is None):
 324            raise ValueError("Missing the required parameter `account_id` when calling `create_brand`")
 325
 326
 327        collection_formats = {}
 328
 329        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
 330        path_params = {}
 331        if 'account_id' in params:
 332            path_params['accountId'] = params['account_id']
 333
 334        query_params = {}
 335
 336        header_params = {}
 337
 338        form_params = []
 339        local_var_files = {}
 340
 341        body_params = None
 342        if 'brand' in params:
 343            body_params = params['brand']
 344        # HTTP header `Accept`
 345        header_params['Accept'] = self.api_client.\
 346            select_header_accept(['application/json'])
 347
 348        # Authentication setting
 349        auth_settings = []
 350
 351        return self.api_client.call_api(resource_path, 'POST',
 352                                        path_params,
 353                                        query_params,
 354                                        header_params,
 355                                        body=body_params,
 356                                        post_params=form_params,
 357                                        files=local_var_files,
 358                                        response_type='BrandsResponse',
 359                                        auth_settings=auth_settings,
 360                                        callback=params.get('callback'),
 361                                        _return_http_data_only=params.get('_return_http_data_only'),
 362                                        _preload_content=params.get('_preload_content', True),
 363                                        _request_timeout=params.get('_request_timeout'),
 364                                        collection_formats=collection_formats)
 365
 366    def create_custom_field(self, account_id, **kwargs):
 367        """
 368        Creates an acount custom field.
 369        This method creates a custom field and makes it available for all new envelopes associated with an account.
 370        This method makes a synchronous HTTP request by default. To make an
 371        asynchronous HTTP request, please define a `callback` function
 372        to be invoked when receiving the response.
 373        >>> def callback_function(response):
 374        >>>     pprint(response)
 375        >>>
 376        >>> thread = api.create_custom_field(account_id, callback=callback_function)
 377
 378        :param callback function: The callback function
 379            for asynchronous request. (optional)
 380        :param str account_id: The external account number (int) or account ID Guid. (required)
 381        :param str apply_to_templates:
 382        :param CustomField custom_field:
 383        :return: CustomFields
 384                 If the method is called asynchronously,
 385                 returns the request thread.
 386        """
 387        kwargs['_return_http_data_only'] = True
 388        if kwargs.get('callback'):
 389            return self.create_custom_field_with_http_info(account_id, **kwargs)
 390        else:
 391            (data) = self.create_custom_field_with_http_info(account_id, **kwargs)
 392            return data
 393
 394    def create_custom_field_with_http_info(self, account_id, **kwargs):
 395        """
 396        Creates an acount custom field.
 397        This method creates a custom field and makes it available for all new envelopes associated with an account.
 398        This method makes a synchronous HTTP request by default. To make an
 399        asynchronous HTTP request, please define a `callback` function
 400        to be invoked when receiving the response.
 401        >>> def callback_function(response):
 402        >>>     pprint(response)
 403        >>>
 404        >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function)
 405
 406        :param callback function: The callback function
 407            for asynchronous request. (optional)
 408        :param str account_id: The external account number (int) or account ID Guid. (required)
 409        :param str apply_to_templates:
 410        :param CustomField custom_field:
 411        :return: CustomFields
 412                 If the method is called asynchronously,
 413                 returns the request thread.
 414        """
 415
 416        all_params = ['account_id', 'apply_to_templates', 'custom_field']
 417        all_params.append('callback')
 418        all_params.append('_return_http_data_only')
 419        all_params.append('_preload_content')
 420        all_params.append('_request_timeout')
 421
 422        params = locals()
 423        for key, val in iteritems(params['kwargs']):
 424            if key not in all_params:
 425                raise TypeError(
 426                    "Got an unexpected keyword argument '%s'"
 427                    " to method create_custom_field" % key
 428                )
 429            params[key] = val
 430        del params['kwargs']
 431        # verify the required parameter 'account_id' is set
 432        if ('account_id' not in params) or (params['account_id'] is None):
 433            raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`")
 434
 435
 436        collection_formats = {}
 437
 438        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
 439        path_params = {}
 440        if 'account_id' in params:
 441            path_params['accountId'] = params['account_id']
 442
 443        query_params = {}
 444        if 'apply_to_templates' in params:
 445            query_params['apply_to_templates'] = params['apply_to_templates']
 446
 447        header_params = {}
 448
 449        form_params = []
 450        local_var_files = {}
 451
 452        body_params = None
 453        if 'custom_field' in params:
 454            body_params = params['custom_field']
 455        # HTTP header `Accept`
 456        header_params['Accept'] = self.api_client.\
 457            select_header_accept(['application/json'])
 458
 459        # Authentication setting
 460        auth_settings = []
 461
 462        return self.api_client.call_api(resource_path, 'POST',
 463                                        path_params,
 464                                        query_params,
 465                                        header_params,
 466                                        body=body_params,
 467                                        post_params=form_params,
 468                                        files=local_var_files,
 469                                        response_type='CustomFields',
 470                                        auth_settings=auth_settings,
 471                                        callback=params.get('callback'),
 472                                        _return_http_data_only=params.get('_return_http_data_only'),
 473                                        _preload_content=params.get('_preload_content', True),
 474                                        _request_timeout=params.get('_request_timeout'),
 475                                        collection_formats=collection_formats)
 476
 477    def create_permission_profile(self, account_id, **kwargs):
 478        """
 479        Creates a new permission profile in the specified account.
 480        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
 481        This method makes a synchronous HTTP request by default. To make an
 482        asynchronous HTTP request, please define a `callback` function
 483        to be invoked when receiving the response.
 484        >>> def callback_function(response):
 485        >>>     pprint(response)
 486        >>>
 487        >>> thread = api.create_permission_profile(account_id, callback=callback_function)
 488
 489        :param callback function: The callback function
 490            for asynchronous request. (optional)
 491        :param str account_id: The external account number (int) or account ID Guid. (required)
 492        :param str include:
 493        :param PermissionProfile permission_profile:
 494        :return: PermissionProfile
 495                 If the method is called asynchronously,
 496                 returns the request thread.
 497        """
 498        kwargs['_return_http_data_only'] = True
 499        if kwargs.get('callback'):
 500            return self.create_permission_profile_with_http_info(account_id, **kwargs)
 501        else:
 502            (data) = self.create_permission_profile_with_http_info(account_id, **kwargs)
 503            return data
 504
 505    def create_permission_profile_with_http_info(self, account_id, **kwargs):
 506        """
 507        Creates a new permission profile in the specified account.
 508        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
 509        This method makes a synchronous HTTP request by default. To make an
 510        asynchronous HTTP request, please define a `callback` function
 511        to be invoked when receiving the response.
 512        >>> def callback_function(response):
 513        >>>     pprint(response)
 514        >>>
 515        >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function)
 516
 517        :param callback function: The callback function
 518            for asynchronous request. (optional)
 519        :param str account_id: The external account number (int) or account ID Guid. (required)
 520        :param str include:
 521        :param PermissionProfile permission_profile:
 522        :return: PermissionProfile
 523                 If the method is called asynchronously,
 524                 returns the request thread.
 525        """
 526
 527        all_params = ['account_id', 'include', 'permission_profile']
 528        all_params.append('callback')
 529        all_params.append('_return_http_data_only')
 530        all_params.append('_preload_content')
 531        all_params.append('_request_timeout')
 532
 533        params = locals()
 534        for key, val in iteritems(params['kwargs']):
 535            if key not in all_params:
 536                raise TypeError(
 537                    "Got an unexpected keyword argument '%s'"
 538                    " to method create_permission_profile" % key
 539                )
 540            params[key] = val
 541        del params['kwargs']
 542        # verify the required parameter 'account_id' is set
 543        if ('account_id' not in params) or (params['account_id'] is None):
 544            raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`")
 545
 546
 547        collection_formats = {}
 548
 549        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
 550        path_params = {}
 551        if 'account_id' in params:
 552            path_params['accountId'] = params['account_id']
 553
 554        query_params = {}
 555        if 'include' in params:
 556            query_params['include'] = params['include']
 557
 558        header_params = {}
 559
 560        form_params = []
 561        local_var_files = {}
 562
 563        body_params = None
 564        if 'permission_profile' in params:
 565            body_params = params['permission_profile']
 566        # HTTP header `Accept`
 567        header_params['Accept'] = self.api_client.\
 568            select_header_accept(['application/json'])
 569
 570        # Authentication setting
 571        auth_settings = []
 572
 573        return self.api_client.call_api(resource_path, 'POST',
 574                                        path_params,
 575                                        query_params,
 576                                        header_params,
 577                                        body=body_params,
 578                                        post_params=form_params,
 579                                        files=local_var_files,
 580                                        response_type='PermissionProfile',
 581                                        auth_settings=auth_settings,
 582                                        callback=params.get('callback'),
 583                                        _return_http_data_only=params.get('_return_http_data_only'),
 584                                        _preload_content=params.get('_preload_content', True),
 585                                        _request_timeout=params.get('_request_timeout'),
 586                                        collection_formats=collection_formats)
 587
 588    def delete(self, account_id, **kwargs):
 589        """
 590        Deletes the specified account.
 591        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
 592        This method makes a synchronous HTTP request by default. To make an
 593        asynchronous HTTP request, please define a `callback` function
 594        to be invoked when receiving the response.
 595        >>> def callback_function(response):
 596        >>>     pprint(response)
 597        >>>
 598        >>> thread = api.delete(account_id, callback=callback_function)
 599
 600        :param callback function: The callback function
 601            for asynchronous request. (optional)
 602        :param str account_id: The external account number (int) or account ID Guid. (required)
 603        :return: None
 604                 If the method is called asynchronously,
 605                 returns the request thread.
 606        """
 607        kwargs['_return_http_data_only'] = True
 608        if kwargs.get('callback'):
 609            return self.delete_with_http_info(account_id, **kwargs)
 610        else:
 611            (data) = self.delete_with_http_info(account_id, **kwargs)
 612            return data
 613
 614    def delete_with_http_info(self, account_id, **kwargs):
 615        """
 616        Deletes the specified account.
 617        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
 618        This method makes a synchronous HTTP request by default. To make an
 619        asynchronous HTTP request, please define a `callback` function
 620        to be invoked when receiving the response.
 621        >>> def callback_function(response):
 622        >>>     pprint(response)
 623        >>>
 624        >>> thread = api.delete_with_http_info(account_id, callback=callback_function)
 625
 626        :param callback function: The callback function
 627            for asynchronous request. (optional)
 628        :param str account_id: The external account number (int) or account ID Guid. (required)
 629        :return: None
 630                 If the method is called asynchronously,
 631                 returns the request thread.
 632        """
 633
 634        all_params = ['account_id']
 635        all_params.append('callback')
 636        all_params.append('_return_http_data_only')
 637        all_params.append('_preload_content')
 638        all_params.append('_request_timeout')
 639
 640        params = locals()
 641        for key, val in iteritems(params['kwargs']):
 642            if key not in all_params:
 643                raise TypeError(
 644                    "Got an unexpected keyword argument '%s'"
 645                    " to method delete" % key
 646                )
 647            params[key] = val
 648        del params['kwargs']
 649        # verify the required parameter 'account_id' is set
 650        if ('account_id' not in params) or (params['account_id'] is None):
 651            raise ValueError("Missing the required parameter `account_id` when calling `delete`")
 652
 653
 654        collection_formats = {}
 655
 656        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
 657        path_params = {}
 658        if 'account_id' in params:
 659            path_params['accountId'] = params['account_id']
 660
 661        query_params = {}
 662
 663        header_params = {}
 664
 665        form_params = []
 666        local_var_files = {}
 667
 668        body_params = None
 669        # HTTP header `Accept`
 670        header_params['Accept'] = self.api_client.\
 671            select_header_accept(['application/json'])
 672
 673        # Authentication setting
 674        auth_settings = []
 675
 676        return self.api_client.call_api(resource_path, 'DELETE',
 677                                        path_params,
 678                                        query_params,
 679                                        header_params,
 680                                        body=body_params,
 681                                        post_params=form_params,
 682                                        files=local_var_files,
 683                                        response_type=None,
 684                                        auth_settings=auth_settings,
 685                                        callback=params.get('callback'),
 686                                        _return_http_data_only=params.get('_return_http_data_only'),
 687                                        _preload_content=params.get('_preload_content', True),
 688                                        _request_timeout=params.get('_request_timeout'),
 689                                        collection_formats=collection_formats)
 690
 691    def delete_account_signature(self, account_id, signature_id, **kwargs):
 692        """
 693        Close the specified signature by Id.
 694        
 695        This method makes a synchronous HTTP request by default. To make an
 696        asynchronous HTTP request, please define a `callback` function
 697        to be invoked when receiving the response.
 698        >>> def callback_function(response):
 699        >>>     pprint(response)
 700        >>>
 701        >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function)
 702
 703        :param callback function: The callback function
 704            for asynchronous request. (optional)
 705        :param str account_id: The external account number (int) or account ID Guid. (required)
 706        :param str signature_id: The ID of the signature being accessed. (required)
 707        :return: None
 708                 If the method is called asynchronously,
 709                 returns the request thread.
 710        """
 711        kwargs['_return_http_data_only'] = True
 712        if kwargs.get('callback'):
 713            return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
 714        else:
 715            (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
 716            return data
 717
 718    def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
 719        """
 720        Close the specified signature by Id.
 721        
 722        This method makes a synchronous HTTP request by default. To make an
 723        asynchronous HTTP request, please define a `callback` function
 724        to be invoked when receiving the response.
 725        >>> def callback_function(response):
 726        >>>     pprint(response)
 727        >>>
 728        >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
 729
 730        :param callback function: The callback function
 731            for asynchronous request. (optional)
 732        :param str account_id: The external account number (int) or account ID Guid. (required)
 733        :param str signature_id: The ID of the signature being accessed. (required)
 734        :return: None
 735                 If the method is called asynchronously,
 736                 returns the request thread.
 737        """
 738
 739        all_params = ['account_id', 'signature_id']
 740        all_params.append('callback')
 741        all_params.append('_return_http_data_only')
 742        all_params.append('_preload_content')
 743        all_params.append('_request_timeout')
 744
 745        params = locals()
 746        for key, val in iteritems(params['kwargs']):
 747            if key not in all_params:
 748                raise TypeError(
 749                    "Got an unexpected keyword argument '%s'"
 750                    " to method delete_account_signature" % key
 751                )
 752            params[key] = val
 753        del params['kwargs']
 754        # verify the required parameter 'account_id' is set
 755        if ('account_id' not in params) or (params['account_id'] is None):
 756            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`")
 757        # verify the required parameter 'signature_id' is set
 758        if ('signature_id' not in params) or (params['signature_id'] is None):
 759            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`")
 760
 761
 762        collection_formats = {}
 763
 764        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
 765        path_params = {}
 766        if 'account_id' in params:
 767            path_params['accountId'] = params['account_id']
 768        if 'signature_id' in params:
 769            path_params['signatureId'] = params['signature_id']
 770
 771        query_params = {}
 772
 773        header_params = {}
 774
 775        form_params = []
 776        local_var_files = {}
 777
 778        body_params = None
 779        # HTTP header `Accept`
 780        header_params['Accept'] = self.api_client.\
 781            select_header_accept(['application/json'])
 782
 783        # Authentication setting
 784        auth_settings = []
 785
 786        return self.api_client.call_api(resource_path, 'DELETE',
 787                                        path_params,
 788                                        query_params,
 789                                        header_params,
 790                                        body=body_params,
 791                                        post_params=form_params,
 792                                        files=local_var_files,
 793                                        response_type=None,
 794                                        auth_settings=auth_settings,
 795                                        callback=params.get('callback'),
 796                                        _return_http_data_only=params.get('_return_http_data_only'),
 797                                        _preload_content=params.get('_preload_content', True),
 798                                        _request_timeout=params.get('_request_timeout'),
 799                                        collection_formats=collection_formats)
 800
 801    def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
 802        """
 803        Deletes a signature, initials, or stamps image.
 804        
 805        This method makes a synchronous HTTP request by default. To make an
 806        asynchronous HTTP request, please define a `callback` function
 807        to be invoked when receiving the response.
 808        >>> def callback_function(response):
 809        >>>     pprint(response)
 810        >>>
 811        >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
 812
 813        :param callback function: The callback function
 814            for asynchronous request. (optional)
 815        :param str account_id: The external account number (int) or account ID Guid. (required)
 816        :param str image_type: One of **signature_image** or **initials_image**. (required)
 817        :param str signature_id: The ID of the signature being accessed. (required)
 818        :return: AccountSignature
 819                 If the method is called asynchronously,
 820                 returns the request thread.
 821        """
 822        kwargs['_return_http_data_only'] = True
 823        if kwargs.get('callback'):
 824            return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
 825        else:
 826            (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
 827            return data
 828
 829    def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
 830        """
 831        Deletes a signature, initials, or stamps image.
 832        
 833        This method makes a synchronous HTTP request by default. To make an
 834        asynchronous HTTP request, please define a `callback` function
 835        to be invoked when receiving the response.
 836        >>> def callback_function(response):
 837        >>>     pprint(response)
 838        >>>
 839        >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
 840
 841        :param callback function: The callback function
 842            for asynchronous request. (optional)
 843        :param str account_id: The external account number (int) or account ID Guid. (required)
 844        :param str image_type: One of **signature_image** or **initials_image**. (required)
 845        :param str signature_id: The ID of the signature being accessed. (required)
 846        :return: AccountSignature
 847                 If the method is called asynchronously,
 848                 returns the request thread.
 849        """
 850
 851        all_params = ['account_id', 'image_type', 'signature_id']
 852        all_params.append('callback')
 853        all_params.append('_return_http_data_only')
 854        all_params.append('_preload_content')
 855        all_params.append('_request_timeout')
 856
 857        params = locals()
 858        for key, val in iteritems(params['kwargs']):
 859            if key not in all_params:
 860                raise TypeError(
 861                    "Got an unexpected keyword argument '%s'"
 862                    " to method delete_account_signature_image" % key
 863                )
 864            params[key] = val
 865        del params['kwargs']
 866        # verify the required parameter 'account_id' is set
 867        if ('account_id' not in params) or (params['account_id'] is None):
 868            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`")
 869        # verify the required parameter 'image_type' is set
 870        if ('image_type' not in params) or (params['image_type'] is None):
 871            raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`")
 872        # verify the required parameter 'signature_id' is set
 873        if ('signature_id' not in params) or (params['signature_id'] is None):
 874            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`")
 875
 876
 877        collection_formats = {}
 878
 879        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
 880        path_params = {}
 881        if 'account_id' in params:
 882            path_params['accountId'] = params['account_id']
 883        if 'image_type' in params:
 884            path_params['imageType'] = params['image_type']
 885        if 'signature_id' in params:
 886            path_params['signatureId'] = params['signature_id']
 887
 888        query_params = {}
 889
 890        header_params = {}
 891
 892        form_params = []
 893        local_var_files = {}
 894
 895        body_params = None
 896        # HTTP header `Accept`
 897        header_params['Accept'] = self.api_client.\
 898            select_header_accept(['application/json'])
 899
 900        # Authentication setting
 901        auth_settings = []
 902
 903        return self.api_client.call_api(resource_path, 'DELETE',
 904                                        path_params,
 905                                        query_params,
 906                                        header_params,
 907                                        body=body_params,
 908                                        post_params=form_params,
 909                                        files=local_var_files,
 910                                        response_type='AccountSignature',
 911                                        auth_settings=auth_settings,
 912                                        callback=params.get('callback'),
 913                                        _return_http_data_only=params.get('_return_http_data_only'),
 914                                        _preload_content=params.get('_preload_content', True),
 915                                        _request_timeout=params.get('_request_timeout'),
 916                                        collection_formats=collection_formats)
 917
 918    def delete_brand(self, account_id, brand_id, **kwargs):
 919        """
 920        Removes a brand.
 921        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
 922        This method makes a synchronous HTTP request by default. To make an
 923        asynchronous HTTP request, please define a `callback` function
 924        to be invoked when receiving the response.
 925        >>> def callback_function(response):
 926        >>>     pprint(response)
 927        >>>
 928        >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function)
 929
 930        :param callback function: The callback function
 931            for asynchronous request. (optional)
 932        :param str account_id: The external account number (int) or account ID Guid. (required)
 933        :param str brand_id: The unique identifier of a brand. (required)
 934        :return: None
 935                 If the method is called asynchronously,
 936                 returns the request thread.
 937        """
 938        kwargs['_return_http_data_only'] = True
 939        if kwargs.get('callback'):
 940            return self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
 941        else:
 942            (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
 943            return data
 944
 945    def delete_brand_with_http_info(self, account_id, brand_id, **kwargs):
 946        """
 947        Removes a brand.
 948        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
 949        This method makes a synchronous HTTP request by default. To make an
 950        asynchronous HTTP request, please define a `callback` function
 951        to be invoked when receiving the response.
 952        >>> def callback_function(response):
 953        >>>     pprint(response)
 954        >>>
 955        >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
 956
 957        :param callback function: The callback function
 958            for asynchronous request. (optional)
 959        :param str account_id: The external account number (int) or account ID Guid. (required)
 960        :param str brand_id: The unique identifier of a brand. (required)
 961        :return: None
 962                 If the method is called asynchronously,
 963                 returns the request thread.
 964        """
 965
 966        all_params = ['account_id', 'brand_id']
 967        all_params.append('callback')
 968        all_params.append('_return_http_data_only')
 969        all_params.append('_preload_content')
 970        all_params.append('_request_timeout')
 971
 972        params = locals()
 973        for key, val in iteritems(params['kwargs']):
 974            if key not in all_params:
 975                raise TypeError(
 976                    "Got an unexpected keyword argument '%s'"
 977                    " to method delete_brand" % key
 978                )
 979            params[key] = val
 980        del params['kwargs']
 981        # verify the required parameter 'account_id' is set
 982        if ('account_id' not in params) or (params['account_id'] is None):
 983            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`")
 984        # verify the required parameter 'brand_id' is set
 985        if ('brand_id' not in params) or (params['brand_id'] is None):
 986            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`")
 987
 988
 989        collection_formats = {}
 990
 991        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
 992        path_params = {}
 993        if 'account_id' in params:
 994            path_params['accountId'] = params['account_id']
 995        if 'brand_id' in params:
 996            path_params['brandId'] = params['brand_id']
 997
 998        query_params = {}
 999
1000        header_params = {}
1001
1002        form_params = []
1003        local_var_files = {}
1004
1005        body_params = None
1006        # HTTP header `Accept`
1007        header_params['Accept'] = self.api_client.\
1008            select_header_accept(['application/json'])
1009
1010        # Authentication setting
1011        auth_settings = []
1012
1013        return self.api_client.call_api(resource_path, 'DELETE',
1014                                        path_params,
1015                                        query_params,
1016                                        header_params,
1017                                        body=body_params,
1018                                        post_params=form_params,
1019                                        files=local_var_files,
1020                                        response_type=None,
1021                                        auth_settings=auth_settings,
1022                                        callback=params.get('callback'),
1023                                        _return_http_data_only=params.get('_return_http_data_only'),
1024                                        _preload_content=params.get('_preload_content', True),
1025                                        _request_timeout=params.get('_request_timeout'),
1026                                        collection_formats=collection_formats)
1027
1028    def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
1029        """
1030        Delete one branding logo.
1031        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1032        This method makes a synchronous HTTP request by default. To make an
1033        asynchronous HTTP request, please define a `callback` function
1034        to be invoked when receiving the response.
1035        >>> def callback_function(response):
1036        >>>     pprint(response)
1037        >>>
1038        >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
1039
1040        :param callback function: The callback function
1041            for asynchronous request. (optional)
1042        :param str account_id: The external account number (int) or account ID Guid. (required)
1043        :param str brand_id: The unique identifier of a brand. (required)
1044        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1045        :return: None
1046                 If the method is called asynchronously,
1047                 returns the request thread.
1048        """
1049        kwargs['_return_http_data_only'] = True
1050        if kwargs.get('callback'):
1051            return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1052        else:
1053            (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1054            return data
1055
1056    def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
1057        """
1058        Delete one branding logo.
1059        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1060        This method makes a synchronous HTTP request by default. To make an
1061        asynchronous HTTP request, please define a `callback` function
1062        to be invoked when receiving the response.
1063        >>> def callback_function(response):
1064        >>>     pprint(response)
1065        >>>
1066        >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
1067
1068        :param callback function: The callback function
1069            for asynchronous request. (optional)
1070        :param str account_id: The external account number (int) or account ID Guid. (required)
1071        :param str brand_id: The unique identifier of a brand. (required)
1072        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1073        :return: None
1074                 If the method is called asynchronously,
1075                 returns the request thread.
1076        """
1077
1078        all_params = ['account_id', 'brand_id', 'logo_type']
1079        all_params.append('callback')
1080        all_params.append('_return_http_data_only')
1081        all_params.append('_preload_content')
1082        all_params.append('_request_timeout')
1083
1084        params = locals()
1085        for key, val in iteritems(params['kwargs']):
1086            if key not in all_params:
1087                raise TypeError(
1088                    "Got an unexpected keyword argument '%s'"
1089                    " to method delete_brand_logo_by_type" % key
1090                )
1091            params[key] = val
1092        del params['kwargs']
1093        # verify the required parameter 'account_id' is set
1094        if ('account_id' not in params) or (params['account_id'] is None):
1095            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`")
1096        # verify the required parameter 'brand_id' is set
1097        if ('brand_id' not in params) or (params['brand_id'] is None):
1098            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`")
1099        # verify the required parameter 'logo_type' is set
1100        if ('logo_type' not in params) or (params['logo_type'] is None):
1101            raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`")
1102
1103
1104        collection_formats = {}
1105
1106        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
1107        path_params = {}
1108        if 'account_id' in params:
1109            path_params['accountId'] = params['account_id']
1110        if 'brand_id' in params:
1111            path_params['brandId'] = params['brand_id']
1112        if 'logo_type' in params:
1113            path_params['logoType'] = params['logo_type']
1114
1115        query_params = {}
1116
1117        header_params = {}
1118
1119        form_params = []
1120        local_var_files = {}
1121
1122        body_params = None
1123        # HTTP header `Accept`
1124        header_params['Accept'] = self.api_client.\
1125            select_header_accept(['application/json'])
1126
1127        # Authentication setting
1128        auth_settings = []
1129
1130        return self.api_client.call_api(resource_path, 'DELETE',
1131                                        path_params,
1132                                        query_params,
1133                                        header_params,
1134                                        body=body_params,
1135                                        post_params=form_params,
1136                                        files=local_var_files,
1137                                        response_type=None,
1138                                        auth_settings=auth_settings,
1139                                        callback=params.get('callback'),
1140                                        _return_http_data_only=params.get('_return_http_data_only'),
1141                                        _preload_content=params.get('_preload_content', True),
1142                                        _request_timeout=params.get('_request_timeout'),
1143                                        collection_formats=collection_formats)
1144
1145    def delete_brands(self, account_id, **kwargs):
1146        """
1147        Deletes one or more brand profiles.
1148        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1149        This method makes a synchronous HTTP request by default. To make an
1150        asynchronous HTTP request, please define a `callback` function
1151        to be invoked when receiving the response.
1152        >>> def callback_function(response):
1153        >>>     pprint(response)
1154        >>>
1155        >>> thread = api.delete_brands(account_id, callback=callback_function)
1156
1157        :param callback function: The callback function
1158            for asynchronous request. (optional)
1159        :param str account_id: The external account number (int) or account ID Guid. (required)
1160        :param BrandsRequest brands_request:
1161        :return: BrandsResponse
1162                 If the method is called asynchronously,
1163                 returns the request thread.
1164        """
1165        kwargs['_return_http_data_only'] = True
1166        if kwargs.get('callback'):
1167            return self.delete_brands_with_http_info(account_id, **kwargs)
1168        else:
1169            (data) = self.delete_brands_with_http_info(account_id, **kwargs)
1170            return data
1171
1172    def delete_brands_with_http_info(self, account_id, **kwargs):
1173        """
1174        Deletes one or more brand profiles.
1175        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1176        This method makes a synchronous HTTP request by default. To make an
1177        asynchronous HTTP request, please define a `callback` function
1178        to be invoked when receiving the response.
1179        >>> def callback_function(response):
1180        >>>     pprint(response)
1181        >>>
1182        >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function)
1183
1184        :param callback function: The callback function
1185            for asynchronous request. (optional)
1186        :param str account_id: The external account number (int) or account ID Guid. (required)
1187        :param BrandsRequest brands_request:
1188        :return: BrandsResponse
1189                 If the method is called asynchronously,
1190                 returns the request thread.
1191        """
1192
1193        all_params = ['account_id', 'brands_request']
1194        all_params.append('callback')
1195        all_params.append('_return_http_data_only')
1196        all_params.append('_preload_content')
1197        all_params.append('_request_timeout')
1198
1199        params = locals()
1200        for key, val in iteritems(params['kwargs']):
1201            if key not in all_params:
1202                raise TypeError(
1203                    "Got an unexpected keyword argument '%s'"
1204                    " to method delete_brands" % key
1205                )
1206            params[key] = val
1207        del params['kwargs']
1208        # verify the required parameter 'account_id' is set
1209        if ('account_id' not in params) or (params['account_id'] is None):
1210            raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`")
1211
1212
1213        collection_formats = {}
1214
1215        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
1216        path_params = {}
1217        if 'account_id' in params:
1218            path_params['accountId'] = params['account_id']
1219
1220        query_params = {}
1221
1222        header_params = {}
1223
1224        form_params = []
1225        local_var_files = {}
1226
1227        body_params = None
1228        if 'brands_request' in params:
1229            body_params = params['brands_request']
1230        # HTTP header `Accept`
1231        header_params['Accept'] = self.api_client.\
1232            select_header_accept(['application/json'])
1233
1234        # Authentication setting
1235        auth_settings = []
1236
1237        return self.api_client.call_api(resource_path, 'DELETE',
1238                                        path_params,
1239                                        query_params,
1240                                        header_params,
1241                                        body=body_params,
1242                                        post_params=form_params,
1243                                        files=local_var_files,
1244                                        response_type='BrandsResponse',
1245                                        auth_settings=auth_settings,
1246                                        callback=params.get('callback'),
1247                                        _return_http_data_only=params.get('_return_http_data_only'),
1248                                        _preload_content=params.get('_preload_content', True),
1249                                        _request_timeout=params.get('_request_timeout'),
1250                                        collection_formats=collection_formats)
1251
1252    def delete_captive_recipient(self, account_id, recipient_part, **kwargs):
1253        """
1254        Deletes the signature for one or more captive recipient records.
1255        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1256        This method makes a synchronous HTTP request by default. To make an
1257        asynchronous HTTP request, please define a `callback` function
1258        to be invoked when receiving the response.
1259        >>> def callback_function(response):
1260        >>>     pprint(response)
1261        >>>
1262        >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function)
1263
1264        :param callback function: The callback function
1265            for asynchronous request. (optional)
1266        :param str account_id: The external account number (int) or account ID Guid. (required)
1267        :param str recipient_part: (required)
1268        :param CaptiveRecipientInformation captive_recipient_information:
1269        :return: CaptiveRecipientInformation
1270                 If the method is called asynchronously,
1271                 returns the request thread.
1272        """
1273        kwargs['_return_http_data_only'] = True
1274        if kwargs.get('callback'):
1275            return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1276        else:
1277            (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1278            return data
1279
1280    def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs):
1281        """
1282        Deletes the signature for one or more captive recipient records.
1283        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1284        This method makes a synchronous HTTP request by default. To make an
1285        asynchronous HTTP request, please define a `callback` function
1286        to be invoked when receiving the response.
1287        >>> def callback_function(response):
1288        >>>     pprint(response)
1289        >>>
1290        >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
1291
1292        :param callback function: The callback function
1293            for asynchronous request. (optional)
1294        :param str account_id: The external account number (int) or account ID Guid. (required)
1295        :param str recipient_part: (required)
1296        :param CaptiveRecipientInformation captive_recipient_information:
1297        :return: CaptiveRecipientInformation
1298                 If the method is called asynchronously,
1299                 returns the request thread.
1300        """
1301
1302        all_params = ['account_id', 'recipient_part', 'captive_recipient_information']
1303        all_params.append('callback')
1304        all_params.append('_return_http_data_only')
1305        all_params.append('_preload_content')
1306        all_params.append('_request_timeout')
1307
1308        params = locals()
1309        for key, val in iteritems(params['kwargs']):
1310            if key not in all_params:
1311                raise TypeError(
1312                    "Got an unexpected keyword argument '%s'"
1313                    " to method delete_captive_recipient" % key
1314                )
1315            params[key] = val
1316        del params['kwargs']
1317        # verify the required parameter 'account_id' is set
1318        if ('account_id' not in params) or (params['account_id'] is None):
1319            raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`")
1320        # verify the required parameter 'recipient_part' is set
1321        if ('recipient_part' not in params) or (params['recipient_part'] is None):
1322            raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`")
1323
1324
1325        collection_formats = {}
1326
1327        resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json')
1328        path_params = {}
1329        if 'account_id' in params:
1330            path_params['accountId'] = params['account_id']
1331        if 'recipient_part' in params:
1332            path_params['recipientPart'] = params['recipient_part']
1333
1334        query_params = {}
1335
1336        header_params = {}
1337
1338        form_params = []
1339        local_var_files = {}
1340
1341        body_params = None
1342        if 'captive_recipient_information' in params:
1343            body_params = params['captive_recipient_information']
1344        # HTTP header `Accept`
1345        header_params['Accept'] = self.api_client.\
1346            select_header_accept(['application/json'])
1347
1348        # Authentication setting
1349        auth_settings = []
1350
1351        return self.api_client.call_api(resource_path, 'DELETE',
1352                                        path_params,
1353                                        query_params,
1354                                        header_params,
1355                                        body=body_params,
1356                                        post_params=form_params,
1357                                        files=local_var_files,
1358                                        response_type='CaptiveRecipientInformation',
1359                                        auth_settings=auth_settings,
1360                                        callback=params.get('callback'),
1361                                        _return_http_data_only=params.get('_return_http_data_only'),
1362                                        _preload_content=params.get('_preload_content', True),
1363                                        _request_timeout=params.get('_request_timeout'),
1364                                        collection_formats=collection_formats)
1365
1366    def delete_custom_field(self, account_id, custom_field_id, **kwargs):
1367        """
1368        Delete an existing account custom field.
1369        This method deletes an existing account custom field.
1370        This method makes a synchronous HTTP request by default. To make an
1371        asynchronous HTTP request, please define a `callback` function
1372        to be invoked when receiving the response.
1373        >>> def callback_function(response):
1374        >>>     pprint(response)
1375        >>>
1376        >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function)
1377
1378        :param callback function: The callback function
1379            for asynchronous request. (optional)
1380        :param str account_id: The external account number (int) or account ID Guid. (required)
1381        :param str custom_field_id: (required)
1382        :param str apply_to_templates:
1383        :return: None
1384                 If the method is called asynchronously,
1385                 returns the request thread.
1386        """
1387        kwargs['_return_http_data_only'] = True
1388        if kwargs.get('callback'):
1389            return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1390        else:
1391            (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1392            return data
1393
1394    def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
1395        """
1396        Delete an existing account custom field.
1397        This method deletes an existing account custom field.
1398        This method makes a synchronous HTTP request by default. To make an
1399        asynchronous HTTP request, please define a `callback` function
1400        to be invoked when receiving the response.
1401        >>> def callback_function(response):
1402        >>>     pprint(response)
1403        >>>
1404        >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
1405
1406        :param callback function: The callback function
1407            for asynchronous request. (optional)
1408        :param str account_id: The external account number (int) or account ID Guid. (required)
1409        :param str custom_field_id: (required)
1410        :param str apply_to_templates:
1411        :return: None
1412                 If the method is called asynchronously,
1413                 returns the request thread.
1414        """
1415
1416        all_params = ['account_id', 'custom_field_id', 'apply_to_templates']
1417        all_params.append('callback')
1418        all_params.append('_return_http_data_only')
1419        all_params.append('_preload_content')
1420        all_params.append('_request_timeout')
1421
1422        params = locals()
1423        for key, val in iteritems(params['kwargs']):
1424            if key not in all_params:
1425                raise TypeError(
1426                    "Got an unexpected keyword argument '%s'"
1427                    " to method delete_custom_field" % key
1428                )
1429            params[key] = val
1430        del params['kwargs']
1431        # verify the required parameter 'account_id' is set
1432        if ('account_id' not in params) or (params['account_id'] is None):
1433            raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`")
1434        # verify the required parameter 'custom_field_id' is set
1435        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
1436            raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`")
1437
1438
1439        collection_formats = {}
1440
1441        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
1442        path_params = {}
1443        if 'account_id' in params:
1444            path_params['accountId'] = params['account_id']
1445        if 'custom_field_id' in params:
1446            path_params['customFieldId'] = params['custom_field_id']
1447
1448        query_params = {}
1449        if 'apply_to_templates' in params:
1450            query_params['apply_to_templates'] = params['apply_to_templates']
1451
1452        header_params = {}
1453
1454        form_params = []
1455        local_var_files = {}
1456
1457        body_params = None
1458        # HTTP header `Accept`
1459        header_params['Accept'] = self.api_client.\
1460            select_header_accept(['application/json'])
1461
1462        # Authentication setting
1463        auth_settings = []
1464
1465        return self.api_client.call_api(resource_path, 'DELETE',
1466                                        path_params,
1467                                        query_params,
1468                                        header_params,
1469                                        body=body_params,
1470                                        post_params=form_params,
1471                                        files=local_var_files,
1472                                        response_type=None,
1473                                        auth_settings=auth_settings,
1474                                        callback=params.get('callback'),
1475                                        _return_http_data_only=params.get('_return_http_data_only'),
1476                                        _preload_content=params.get('_preload_content', True),
1477                                        _request_timeout=params.get('_request_timeout'),
1478                                        collection_formats=collection_formats)
1479
1480    def delete_e_note_configuration(self, account_id, **kwargs):
1481        """
1482        Deletes configuration information for the eNote eOriginal integration.
1483        
1484        This method makes a synchronous HTTP request by default. To make an
1485        asynchronous HTTP request, please define a `callback` function
1486        to be invoked when receiving the response.
1487        >>> def callback_function(response):
1488        >>>     pprint(response)
1489        >>>
1490        >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function)
1491
1492        :param callback function: The callback function
1493            for asynchronous request. (optional)
1494        :param str account_id: The external account number (int) or account ID Guid. (required)
1495        :return: None
1496                 If the method is called asynchronously,
1497                 returns the request thread.
1498        """
1499        kwargs['_return_http_data_only'] = True
1500        if kwargs.get('callback'):
1501            return self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1502        else:
1503            (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1504            return data
1505
1506    def delete_e_note_configuration_with_http_info(self, account_id, **kwargs):
1507        """
1508        Deletes configuration information for the eNote eOriginal integration.
1509        
1510        This method makes a synchronous HTTP request by default. To make an
1511        asynchronous HTTP request, please define a `callback` function
1512        to be invoked when receiving the response.
1513        >>> def callback_function(response):
1514        >>>     pprint(response)
1515        >>>
1516        >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function)
1517
1518        :param callback function: The callback function
1519            for asynchronous request. (optional)
1520        :param str account_id: The external account number (int) or account ID Guid. (required)
1521        :return: None
1522                 If the method is called asynchronously,
1523                 returns the request thread.
1524        """
1525
1526        all_params = ['account_id']
1527        all_params.append('callback')
1528        all_params.append('_return_http_data_only')
1529        all_params.append('_preload_content')
1530        all_params.append('_request_timeout')
1531
1532        params = locals()
1533        for key, val in iteritems(params['kwargs']):
1534            if key not in all_params:
1535                raise TypeError(
1536                    "Got an unexpected keyword argument '%s'"
1537                    " to method delete_e_note_configuration" % key
1538                )
1539            params[key] = val
1540        del params['kwargs']
1541        # verify the required parameter 'account_id' is set
1542        if ('account_id' not in params) or (params['account_id'] is None):
1543            raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`")
1544
1545
1546        collection_formats = {}
1547
1548        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
1549        path_params = {}
1550        if 'account_id' in params:
1551            path_params['accountId'] = params['account_id']
1552
1553        query_params = {}
1554
1555        header_params = {}
1556
1557        form_params = []
1558        local_var_files = {}
1559
1560        body_params = None
1561        # HTTP header `Accept`
1562        header_params['Accept'] = self.api_client.\
1563            select_header_accept(['application/json'])
1564
1565        # Authentication setting
1566        auth_settings = []
1567
1568        return self.api_client.call_api(resource_path, 'DELETE',
1569                                        path_params,
1570                                        query_params,
1571                                        header_params,
1572                                        body=body_params,
1573                                        post_params=form_params,
1574                                        files=local_var_files,
1575                                        response_type=None,
1576                                        auth_settings=auth_settings,
1577                                        callback=params.get('callback'),
1578                                        _return_http_data_only=params.get('_return_http_data_only'),
1579                                        _preload_content=params.get('_preload_content', True),
1580                                        _request_timeout=params.get('_request_timeout'),
1581                                        collection_formats=collection_formats)
1582
1583    def delete_permission_profile(self, account_id, permission_profile_id, **kwargs):
1584        """
1585        Deletes a permissions profile within the specified account.
1586        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1587        This method makes a synchronous HTTP request by default. To make an
1588        asynchronous HTTP request, please define a `callback` function
1589        to be invoked when receiving the response.
1590        >>> def callback_function(response):
1591        >>>     pprint(response)
1592        >>>
1593        >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function)
1594
1595        :param callback function: The callback function
1596            for asynchronous request. (optional)
1597        :param str account_id: The external account number (int) or account ID Guid. (required)
1598        :param str permission_profile_id: (required)
1599        :param str move_users_to:
1600        :return: None
1601                 If the method is called asynchronously,
1602                 returns the request thread.
1603        """
1604        kwargs['_return_http_data_only'] = True
1605        if kwargs.get('callback'):
1606            return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1607        else:
1608            (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1609            return data
1610
1611    def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
1612        """
1613        Deletes a permissions profile within the specified account.
1614        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1615        This method makes a synchronous HTTP request by default. To make an
1616        asynchronous HTTP request, please define a `callback` function
1617        to be invoked when receiving the response.
1618        >>> def callback_function(response):
1619        >>>     pprint(response)
1620        >>>
1621        >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
1622
1623        :param callback function: The callback function
1624            for asynchronous request. (optional)
1625        :param str account_id: The external account number (int) or account ID Guid. (required)
1626        :param str permission_profile_id: (required)
1627        :param str move_users_to:
1628        :return: None
1629                 If the method is called asynchronously,
1630                 returns the request thread.
1631        """
1632
1633        all_params = ['account_id', 'permission_profile_id', 'move_users_to']
1634        all_params.append('callback')
1635        all_params.append('_return_http_data_only')
1636        all_params.append('_preload_content')
1637        all_params.append('_request_timeout')
1638
1639        params = locals()
1640        for key, val in iteritems(params['kwargs']):
1641            if key not in all_params:
1642                raise TypeError(
1643                    "Got an unexpected keyword argument '%s'"
1644                    " to method delete_permission_profile" % key
1645                )
1646            params[key] = val
1647        del params['kwargs']
1648        # verify the required parameter 'account_id' is set
1649        if ('account_id' not in params) or (params['account_id'] is None):
1650            raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`")
1651        # verify the required parameter 'permission_profile_id' is set
1652        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
1653            raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`")
1654
1655
1656        collection_formats = {}
1657
1658        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
1659        path_params = {}
1660        if 'account_id' in params:
1661            path_params['accountId'] = params['account_id']
1662        if 'permission_profile_id' in params:
1663            path_params['permissionProfileId'] = params['permission_profile_id']
1664
1665        query_params = {}
1666        if 'move_users_to' in params:
1667            query_params['move_users_to'] = params['move_users_to']
1668
1669        header_params = {}
1670
1671        form_params = []
1672        local_var_files = {}
1673
1674        body_params = None
1675        # HTTP header `Accept`
1676        header_params['Accept'] = self.api_client.\
1677            select_header_accept(['application/json'])
1678
1679        # Authentication setting
1680        auth_settings = []
1681
1682        return self.api_client.call_api(resource_path, 'DELETE',
1683                                        path_params,
1684                                        query_params,
1685                                        header_params,
1686                                        body=body_params,
1687                                        post_params=form_params,
1688                                        files=local_var_files,
1689                                        response_type=None,
1690                                        auth_settings=auth_settings,
1691                                        callback=params.get('callback'),
1692                                        _return_http_data_only=params.get('_return_http_data_only'),
1693                                        _preload_content=params.get('_preload_content', True),
1694                                        _request_timeout=params.get('_request_timeout'),
1695                                        collection_formats=collection_formats)
1696
1697    def get_account_identity_verification(self, account_id, **kwargs):
1698        """
1699        Get the list of identity verification options for an account
1700        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1701        This method makes a synchronous HTTP request by default. To make an
1702        asynchronous HTTP request, please define a `callback` function
1703        to be invoked when receiving the response.
1704        >>> def callback_function(response):
1705        >>>     pprint(response)
1706        >>>
1707        >>> thread = api.get_account_identity_verification(account_id, callback=callback_function)
1708
1709        :param callback function: The callback function
1710            for asynchronous request. (optional)
1711        :param str account_id: The external account number (int) or account ID Guid. (required)
1712        :return: AccountIdentityVerificationResponse
1713                 If the method is called asynchronously,
1714                 returns the request thread.
1715        """
1716        kwargs['_return_http_data_only'] = True
1717        if kwargs.get('callback'):
1718            return self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1719        else:
1720            (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1721            return data
1722
1723    def get_account_identity_verification_with_http_info(self, account_id, **kwargs):
1724        """
1725        Get the list of identity verification options for an account
1726        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1727        This method makes a synchronous HTTP request by default. To make an
1728        asynchronous HTTP request, please define a `callback` function
1729        to be invoked when receiving the response.
1730        >>> def callback_function(response):
1731        >>>     pprint(response)
1732        >>>
1733        >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function)
1734
1735        :param callback function: The callback function
1736            for asynchronous request. (optional)
1737        :param str account_id: The external account number (int) or account ID Guid. (required)
1738        :return: AccountIdentityVerificationResponse
1739                 If the method is called asynchronously,
1740                 returns the request thread.
1741        """
1742
1743        all_params = ['account_id']
1744        all_params.append('callback')
1745        all_params.append('_return_http_data_only')
1746        all_params.append('_preload_content')
1747        all_params.append('_request_timeout')
1748
1749        params = locals()
1750        for key, val in iteritems(params['kwargs']):
1751            if key not in all_params:
1752                raise TypeError(
1753                    "Got an unexpected keyword argument '%s'"
1754                    " to method get_account_identity_verification" % key
1755                )
1756            params[key] = val
1757        del params['kwargs']
1758        # verify the required parameter 'account_id' is set
1759        if ('account_id' not in params) or (params['account_id'] is None):
1760            raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`")
1761
1762
1763        collection_formats = {}
1764
1765        resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json')
1766        path_params = {}
1767        if 'account_id' in params:
1768            path_params['accountId'] = params['account_id']
1769
1770        query_params = {}
1771
1772        header_params = {}
1773
1774        form_params = []
1775        local_var_files = {}
1776
1777        body_params = None
1778        # HTTP header `Accept`
1779        header_params['Accept'] = self.api_client.\
1780            select_header_accept(['application/json'])
1781
1782        # Authentication setting
1783        auth_settings = []
1784
1785        return self.api_client.call_api(resource_path, 'GET',
1786                                        path_params,
1787                                        query_params,
1788                                        header_params,
1789                                        body=body_params,
1790                                        post_params=form_params,
1791                                        files=local_var_files,
1792                                        response_type='AccountIdentityVerificationResponse',
1793                                        auth_settings=auth_settings,
1794                                        callback=params.get('callback'),
1795                                        _return_http_data_only=params.get('_return_http_data_only'),
1796                                        _preload_content=params.get('_preload_content', True),
1797                                        _request_timeout=params.get('_request_timeout'),
1798                                        collection_formats=collection_formats)
1799
1800    def get_account_information(self, account_id, **kwargs):
1801        """
1802        Retrieves the account information for the specified account.
1803        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1804        This method makes a synchronous HTTP request by default. To make an
1805        asynchronous HTTP request, please define a `callback` function
1806        to be invoked when receiving the response.
1807        >>> def callback_function(response):
1808        >>>     pprint(response)
1809        >>>
1810        >>> thread = api.get_account_information(account_id, callback=callback_function)
1811
1812        :param callback function: The callback function
1813            for asynchronous request. (optional)
1814        :param str account_id: The external account number (int) or account ID Guid. (required)
1815        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1816        :return: AccountInformation
1817                 If the method is called asynchronously,
1818                 returns the request thread.
1819        """
1820        kwargs['_return_http_data_only'] = True
1821        if kwargs.get('callback'):
1822            return self.get_account_information_with_http_info(account_id, **kwargs)
1823        else:
1824            (data) = self.get_account_information_with_http_info(account_id, **kwargs)
1825            return data
1826
1827    def get_account_information_with_http_info(self, account_id, **kwargs):
1828        """
1829        Retrieves the account information for the specified account.
1830        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1831        This method makes a synchronous HTTP request by default. To make an
1832        asynchronous HTTP request, please define a `callback` function
1833        to be invoked when receiving the response.
1834        >>> def callback_function(response):
1835        >>>     pprint(response)
1836        >>>
1837        >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
1838
1839        :param callback function: The callback function
1840            for asynchronous request. (optional)
1841        :param str account_id: The external account number (int) or account ID Guid. (required)
1842        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1843        :return: AccountInformation
1844                 If the method is called asynchronously,
1845                 returns the request thread.
1846        """
1847
1848        all_params = ['account_id', 'include_account_settings']
1849        all_params.append('callback')
1850        all_params.append('_return_http_data_only')
1851        all_params.append('_preload_content')
1852        all_params.append('_request_timeout')
1853
1854        params = locals()
1855        for key, val in iteritems(params['kwargs']):
1856            if key not in all_params:
1857                raise TypeError(
1858                    "Got an unexpected keyword argument '%s'"
1859                    " to method get_account_information" % key
1860                )
1861            params[key] = val
1862        del params['kwargs']
1863        # verify the required parameter 'account_id' is set
1864        if ('account_id' not in params) or (params['account_id'] is None):
1865            raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`")
1866
1867
1868        collection_formats = {}
1869
1870        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
1871        path_params = {}
1872        if 'account_id' in params:
1873            path_params['accountId'] = params['account_id']
1874
1875        query_params = {}
1876        if 'include_account_settings' in params:
1877            query_params['include_account_settings'] = params['include_account_settings']
1878
1879        header_params = {}
1880
1881        form_params = []
1882        local_var_files = {}
1883
1884        body_params = None
1885        # HTTP header `Accept`
1886        header_params['Accept'] = self.api_client.\
1887            select_header_accept(['application/json'])
1888
1889        # Authentication setting
1890        auth_settings = []
1891
1892        return self.api_client.call_api(resource_path, 'GET',
1893                                        path_params,
1894                                        query_params,
1895                                        header_params,
1896                                        body=body_params,
1897                                        post_params=form_params,
1898                                        files=local_var_files,
1899                                        response_type='AccountInformation',
1900                                        auth_settings=auth_settings,
1901                                        callback=params.get('callback'),
1902                                        _return_http_data_only=params.get('_return_http_data_only'),
1903                                        _preload_content=params.get('_preload_content', True),
1904                                        _request_timeout=params.get('_request_timeout'),
1905                                        collection_formats=collection_formats)
1906
1907    def get_account_signature(self, account_id, signature_id, **kwargs):
1908        """
1909        Returns information about a single signature by specifed signatureId.
1910        
1911        This method makes a synchronous HTTP request by default. To make an
1912        asynchronous HTTP request, please define a `callback` function
1913        to be invoked when receiving the response.
1914        >>> def callback_function(response):
1915        >>>     pprint(response)
1916        >>>
1917        >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function)
1918
1919        :param callback function: The callback function
1920            for asynchronous request. (optional)
1921        :param str account_id: The external account number (int) or account ID Guid. (required)
1922        :param str signature_id: The ID of the signature being accessed. (required)
1923        :return: AccountSignature
1924                 If the method is called asynchronously,
1925                 returns the request thread.
1926        """
1927        kwargs['_return_http_data_only'] = True
1928        if kwargs.get('callback'):
1929            return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1930        else:
1931            (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1932            return data
1933
1934    def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
1935        """
1936        Returns information about a single signature by specifed signatureId.
1937        
1938        This method makes a synchronous HTTP request by default. To make an
1939        asynchronous HTTP request, please define a `callback` function
1940        to be invoked when receiving the response.
1941        >>> def callback_function(response):
1942        >>>     pprint(response)
1943        >>>
1944        >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
1945
1946        :param callback function: The callback function
1947            for asynchronous request. (optional)
1948        :param str account_id: The external account number (int) or account ID Guid. (required)
1949        :param str signature_id: The ID of the signature being accessed. (required)
1950        :return: AccountSignature
1951                 If the method is called asynchronously,
1952                 returns the request thread.
1953        """
1954
1955        all_params = ['account_id', 'signature_id']
1956        all_params.append('callback')
1957        all_params.append('_return_http_data_only')
1958        all_params.append('_preload_content')
1959        all_params.append('_request_timeout')
1960
1961        params = locals()
1962        for key, val in iteritems(params['kwargs']):
1963            if key not in all_params:
1964                raise TypeError(
1965                    "Got an unexpected keyword argument '%s'"
1966                    " to method get_account_signature" % key
1967                )
1968            params[key] = val
1969        del params['kwargs']
1970        # verify the required parameter 'account_id' is set
1971        if ('account_id' not in params) or (params['account_id'] is None):
1972            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`")
1973        # verify the required parameter 'signature_id' is set
1974        if ('signature_id' not in params) or (params['signature_id'] is None):
1975            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`")
1976
1977
1978        collection_formats = {}
1979
1980        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
1981        path_params = {}
1982        if 'account_id' in params:
1983            path_params['accountId'] = params['account_id']
1984        if 'signature_id' in params:
1985            path_params['signatureId'] = params['signature_id']
1986
1987        query_params = {}
1988
1989        header_params = {}
1990
1991        form_params = []
1992        local_var_files = {}
1993
1994        body_params = None
1995        # HTTP header `Accept`
1996        header_params['Accept'] = self.api_client.\
1997            select_header_accept(['application/json'])
1998
1999        # Authentication setting
2000        auth_settings = []
2001
2002        return self.api_client.call_api(resource_path, 'GET',
2003                                        path_params,
2004                                        query_params,
2005                                        header_params,
2006                                        body=body_params,
2007                                        post_params=form_params,
2008                                        files=local_var_files,
2009                                        response_type='AccountSignature',
2010                                        auth_settings=auth_settings,
2011                                        callback=params.get('callback'),
2012                                        _return_http_data_only=params.get('_return_http_data_only'),
2013                                        _preload_content=params.get('_preload_content', True),
2014                                        _request_timeout=params.get('_request_timeout'),
2015                                        collection_formats=collection_formats)
2016
2017    def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
2018        """
2019        Returns a signature, initials, or stamps image.
2020        
2021        This method makes a synchronous HTTP request by default. To make an
2022        asynchronous HTTP request, please define a `callback` function
2023        to be invoked when receiving the response.
2024        >>> def callback_function(response):
2025        >>>     pprint(response)
2026        >>>
2027        >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
2028
2029        :param callback function: The callback function
2030            for asynchronous request. (optional)
2031        :param str account_id: The external account number (int) or account ID Guid. (required)
2032        :param str image_type: One of **signature_image** or **initials_image**. (required)
2033        :param str signature_id: The ID of the signature being accessed. (required)
2034        :param str include_chrome:
2035        :return: file
2036                 If the method is called asynchronously,
2037                 returns the request thread.
2038        """
2039        kwargs['_return_http_data_only'] = True
2040        if kwargs.get('callback'):
2041            return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2042        else:
2043            (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2044            return data
2045
2046    def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
2047        """
2048        Returns a signature, initials, or stamps image.
2049        
2050        This method makes a synchronous HTTP request by default. To make an
2051        asynchronous HTTP request, please define a `callback` function
2052        to be invoked when receiving the response.
2053        >>> def callback_function(response):
2054        >>>     pprint(response)
2055        >>>
2056        >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
2057
2058        :param callback function: The callback function
2059            for asynchronous request. (optional)
2060        :param str account_id: The external account number (int) or account ID Guid. (required)
2061        :param str image_type: One of **signature_image** or **initials_image**. (required)
2062        :param str signature_id: The ID of the signature being accessed. (required)
2063        :param str include_chrome:
2064        :return: file
2065                 If the method is called asynchronously,
2066                 returns the request thread.
2067        """
2068
2069        all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome']
2070        all_params.append('callback')
2071        all_params.append('_return_http_data_only')
2072        all_params.append('_preload_content')
2073        all_params.append('_request_timeout')
2074
2075        params = locals()
2076        for key, val in iteritems(params['kwargs']):
2077            if key not in all_params:
2078                raise TypeError(
2079                    "Got an unexpected keyword argument '%s'"
2080                    " to method get_account_signature_image" % key
2081                )
2082            params[key] = val
2083        del params['kwargs']
2084        # verify the required parameter 'account_id' is set
2085        if ('account_id' not in params) or (params['account_id'] is None):
2086            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`")
2087        # verify the required parameter 'image_type' is set
2088        if ('image_type' not in params) or (params['image_type'] is None):
2089            raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`")
2090        # verify the required parameter 'signature_id' is set
2091        if ('signature_id' not in params) or (params['signature_id'] is None):
2092            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`")
2093
2094
2095        collection_formats = {}
2096
2097        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
2098        path_params = {}
2099        if 'account_id' in params:
2100            path_params['accountId'] = params['account_id']
2101        if 'image_type' in params:
2102            path_params['imageType'] = params['image_type']
2103        if 'signature_id' in params:
2104            path_params['signatureId'] = params['signature_id']
2105
2106        query_params = {}
2107        if 'include_chrome' in params:
2108            query_params['include_chrome'] = params['include_chrome']
2109
2110        header_params = {}
2111
2112        form_params = []
2113        local_var_files = {}
2114
2115        body_params = None
2116        # HTTP header `Accept`
2117        header_params['Accept'] = self.api_client.\
2118            select_header_accept(['image/gif'])
2119
2120        # Authentication setting
2121        auth_settings = []
2122
2123        return self.api_client.call_api(resource_path, 'GET',
2124                                        path_params,
2125                                        query_params,
2126                                        header_params,
2127                                        body=body_params,
2128                                        post_params=form_params,
2129                                        files=local_var_files,
2130                                        response_type='file',
2131                                        auth_settings=auth_settings,
2132                                        callback=params.get('callback'),
2133                                        _return_http_data_only=params.get('_return_http_data_only'),
2134                                        _preload_content=params.get('_preload_content', True),
2135                                        _request_timeout=params.get('_request_timeout'),
2136                                        collection_formats=collection_formats)
2137
2138    def get_account_signatures(self, account_id, **kwargs):
2139        """
2140        Returns the managed signature definitions for the account
2141        
2142        This method makes a synchronous HTTP request by default. To make an
2143        asynchronous HTTP request, please define a `callback` function
2144        to be invoked when receiving the response.
2145        >>> def callback_function(response):
2146        >>>     pprint(response)
2147        >>>
2148        >>> thread = api.get_account_signatures(account_id, callback=callback_function)
2149
2150        :param callback function: The callback function
2151            for asynchronous request. (optional)
2152        :param str account_id: The external account number (int) or account ID Guid. (required)
2153        :param str stamp_format:
2154        :param str stamp_name:
2155        :param str stamp_type:
2156        :return: AccountSignaturesInformation
2157                 If the method is called asynchronously,
2158                 returns the request thread.
2159        """
2160        kwargs['_return_http_data_only'] = True
2161        if kwargs.get('callback'):
2162            return self.get_account_signatures_with_http_info(account_id, **kwargs)
2163        else:
2164            (data) = self.get_account_signatures_with_http_info(account_id, **kwargs)
2165            return data
2166
2167    def get_account_signatures_with_http_info(self, account_id, **kwargs):
2168        """
2169        Returns the managed signature definitions for the account
2170        
2171        This method makes a synchronous HTTP request by default. To make an
2172        asynchronous HTTP request, please define a `callback` function
2173        to be invoked when receiving the response.
2174        >>> def callback_function(response):
2175        >>>     pprint(response)
2176        >>>
2177        >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function)
2178
2179        :param callback function: The callback function
2180            for asynchronous request. (optional)
2181        :param str account_id: The external account number (int) or account ID Guid. (required)
2182        :param str stamp_format:
2183        :param str stamp_name:
2184        :param str stamp_type:
2185        :return: AccountSignaturesInformation
2186                 If the method is called asynchronously,
2187                 returns the request thread.
2188        """
2189
2190        all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type']
2191        all_params.append('callback')
2192        all_params.append('_return_http_data_only')
2193        all_params.append('_preload_content')
2194        all_params.append('_request_timeout')
2195
2196        params = locals()
2197        for key, val in iteritems(params['kwargs']):
2198            if key not in all_params:
2199                raise TypeError(
2200                    "Got an unexpected keyword argument '%s'"
2201                    " to method get_account_signatures" % key
2202                )
2203            params[key] = val
2204        del params['kwargs']
2205        # verify the required parameter 'account_id' is set
2206        if ('account_id' not in params) or (params['account_id'] is None):
2207            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`")
2208
2209
2210        collection_formats = {}
2211
2212        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
2213        path_params = {}
2214        if 'account_id' in params:
2215            path_params['accountId'] = params['account_id']
2216
2217        query_params = {}
2218        if 'stamp_format' in params:
2219            query_params['stamp_format'] = params['stamp_format']
2220        if 'stamp_name' in params:
2221            query_params['stamp_name'] = params['stamp_name']
2222        if 'stamp_type' in params:
2223            query_params['stamp_type'] = params['stamp_type']
2224
2225        header_params = {}
2226
2227        form_params = []
2228        local_var_files = {}
2229
2230        body_params = None
2231        # HTTP header `Accept`
2232        header_params['Accept'] = self.api_client.\
2233            select_header_accept(['application/json'])
2234
2235        # Authentication setting
2236        auth_settings = []
2237
2238        return self.api_client.call_api(resource_path, 'GET',
2239                                        path_params,
2240                                        query_params,
2241                                        header_params,
2242                                        body=body_params,
2243                                        post_params=form_params,
2244                                        files=local_var_files,
2245                                        response_type='AccountSignaturesInformation',
2246                                        auth_settings=auth_settings,
2247                                        callback=params.get('callback'),
2248                                        _return_http_data_only=params.get('_return_http_data_only'),
2249                                        _preload_content=params.get('_preload_content', True),
2250                                        _request_timeout=params.get('_request_timeout'),
2251                                        collection_formats=collection_formats)
2252
2253    def get_account_tab_settings(self, account_id, **kwargs):
2254        """
2255        Returns tab settings list for specified account
2256        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2257        This method makes a synchronous HTTP request by default. To make an
2258        asynchronous HTTP request, please define a `callback` function
2259        to be invoked when receiving the response.
2260        >>> def callback_function(response):
2261        >>>     pprint(response)
2262        >>>
2263        >>> thread = api.get_account_tab_settings(account_id, callback=callback_function)
2264
2265        :param callback function: The callback function
2266            for asynchronous request. (optional)
2267        :param str account_id: The external account number (int) or account ID Guid. (required)
2268        :return: TabAccountSettings
2269                 If the method is called asynchronously,
2270                 returns the request thread.
2271        """
2272        kwargs['_return_http_data_only'] = True
2273        if kwargs.get('callback'):
2274            return self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2275        else:
2276            (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2277            return data
2278
2279    def get_account_tab_settings_with_http_info(self, account_id, **kwargs):
2280        """
2281        Returns tab settings list for specified account
2282        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2283        This method makes a synchronous HTTP request by default. To make an
2284        asynchronous HTTP request, please define a `callback` function
2285        to be invoked when receiving the response.
2286        >>> def callback_function(response):
2287        >>>     pprint(response)
2288        >>>
2289        >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function)
2290
2291        :param callback function: The callback function
2292            for asynchronous request. (optional)
2293        :param str account_id: The external account number (int) or account ID Guid. (required)
2294        :return: TabAccountSettings
2295                 If the method is called asynchronously,
2296                 returns the request thread.
2297        """
2298
2299        all_params = ['account_id']
2300        all_params.append('callback')
2301        all_params.append('_return_http_data_only')
2302        all_params.append('_preload_content')
2303        all_params.append('_request_timeout')
2304
2305        params = locals()
2306        for key, val in iteritems(params['kwargs']):
2307            if key not in all_params:
2308                raise TypeError(
2309                    "Got an unexpected keyword argument '%s'"
2310                    " to method get_account_tab_settings" % key
2311                )
2312            params[key] = val
2313        del params['kwargs']
2314        # verify the required parameter 'account_id' is set
2315        if ('account_id' not in params) or (params['account_id'] is None):
2316            raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`")
2317
2318
2319        collection_formats = {}
2320
2321        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
2322        path_params = {}
2323        if 'account_id' in params:
2324            path_params['accountId'] = params['account_id']
2325
2326        query_params = {}
2327
2328        header_params = {}
2329
2330        form_params = []
2331        local_var_files = {}
2332
2333        body_params = None
2334        # HTTP header `Accept`
2335        header_params['Accept'] = self.api_client.\
2336            select_header_accept(['application/json'])
2337
2338        # Authentication setting
2339        auth_settings = []
2340
2341        return self.api_client.call_api(resource_path, 'GET',
2342                                        path_params,
2343                                        query_params,
2344                                        header_params,
2345                                        body=body_params,
2346                                        post_params=form_params,
2347                                        files=local_var_files,
2348                                        response_type='TabAccountSettings',
2349                                        auth_settings=auth_settings,
2350                                        callback=params.get('callback'),
2351                                        _return_http_data_only=params.get('_return_http_data_only'),
2352                                        _preload_content=params.get('_preload_content', True),
2353                                        _request_timeout=params.get('_request_timeout'),
2354                                        collection_formats=collection_formats)
2355
2356    def get_all_payment_gateway_accounts(self, account_id, **kwargs):
2357        """
2358        Get all payment gateway account for the provided accountId
2359        This method returns a list of payment gateway accounts and basic information about them.
2360        This method makes a synchronous HTTP request by default. To make an
2361        asynchronous HTTP request, please define a `callback` function
2362        to be invoked when receiving the response.
2363        >>> def callback_function(response):
2364        >>>     pprint(response)
2365        >>>
2366        >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function)
2367
2368        :param callback function: The callback function
2369            for asynchronous request. (optional)
2370        :param str account_id: The external account number (int) or account ID Guid. (required)
2371        :return: PaymentGatewayAccountsInfo
2372                 If the method is called asynchronously,
2373                 returns the request thread.
2374        """
2375        kwargs['_return_http_data_only'] = True
2376        if kwargs.get('callback'):
2377            return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2378        else:
2379            (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2380            return data
2381
2382    def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs):
2383        """
2384        Get all payment gateway account for the provided accountId
2385        This method returns a list of payment gateway accounts and basic information about them.
2386        This method makes a synchronous HTTP request by default. To make an
2387        asynchronous HTTP request, please define a `callback` function
2388        to be invoked when receiving the response.
2389        >>> def callback_function(response):
2390        >>>     pprint(response)
2391        >>>
2392        >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function)
2393
2394        :param callback function: The callback function
2395            for asynchronous request. (optional)
2396        :param str account_id: The external account number (int) or account ID Guid. (required)
2397        :return: PaymentGatewayAccountsInfo
2398                 If the method is called asynchronously,
2399                 returns the request thread.
2400        """
2401
2402        all_params = ['account_id']
2403        all_params.append('callback')
2404        all_params.append('_return_http_data_only')
2405        all_params.append('_preload_content')
2406        all_params.append('_request_timeout')
2407
2408        params = locals()
2409        for key, val in iteritems(params['kwargs']):
2410            if key not in all_params:
2411                raise TypeError(
2412                    "Got an unexpected keyword argument '%s'"
2413                    " to method get_all_payment_gateway_accounts" % key
2414                )
2415            params[key] = val
2416        del params['kwargs']
2417        # verify the required parameter 'account_id' is set
2418        if ('account_id' not in params) or (params['account_id'] is None):
2419            raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`")
2420
2421
2422        collection_formats = {}
2423
2424        resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json')
2425        path_params = {}
2426        if 'account_id' in params:
2427            path_params['accountId'] = params['account_id']
2428
2429        query_params = {}
2430
2431        header_params = {}
2432
2433        form_params = []
2434        local_var_files = {}
2435
2436        body_params = None
2437        # HTTP header `Accept`
2438        header_params['Accept'] = self.api_client.\
2439            select_header_accept(['application/json'])
2440
2441        # Authentication setting
2442        auth_settings = []
2443
2444        return self.api_client.call_api(resource_path, 'GET',
2445                                        path_params,
2446                                        query_params,
2447                                        header_params,
2448                                        body=body_params,
2449                                        post_params=form_params,
2450                                        files=local_var_files,
2451                                        response_type='PaymentGatewayAccountsInfo',
2452                                        auth_settings=auth_settings,
2453                                        callback=params.get('callback'),
2454                                        _return_http_data_only=params.get('_return_http_data_only'),
2455                                        _preload_content=params.get('_preload_content', True),
2456                                        _request_timeout=params.get('_request_timeout'),
2457                                        collection_formats=collection_formats)
2458
2459    def get_billing_charges(self, account_id, **kwargs):
2460        """
2461        Gets list of recurring and usage charges for the account.
2462        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2463        This method makes a synchronous HTTP request by default. To make an
2464        asynchronous HTTP request, please define a `callback` function
2465        to be invoked when receiving the response.
2466        >>> def callback_function(response):
2467        >>>     pprint(response)
2468        >>>
2469        >>> thread = api.get_billing_charges(account_id, callback=callback_function)
2470
2471        :param callback function: The callback function
2472            for asynchronous request. (optional)
2473        :param str account_id: The external account number (int) or account ID Guid. (required)
2474        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2475        :return: BillingChargeResponse
2476                 If the method is called asynchronously,
2477                 returns the request thread.
2478        """
2479        kwargs['_return_http_data_only'] = True
2480        if kwargs.get('callback'):
2481            return self.get_billing_charges_with_http_info(account_id, **kwargs)
2482        else:
2483            (data) = self.get_billing_charges_with_http_info(account_id, **kwargs)
2484            return data
2485
2486    def get_billing_charges_with_http_info(self, account_id, **kwargs):
2487        """
2488        Gets list of recurring and usage charges for the account.
2489        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2490        This method makes a synchronous HTTP request by default. To make an
2491        asynchronous HTTP request, please define a `callback` function
2492        to be invoked when receiving the response.
2493        >>> def callback_function(response):
2494        >>>     pprint(response)
2495        >>>
2496        >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function)
2497
2498        :param callback function: The callback function
2499            for asynchronous request. (optional)
2500        :param str account_id: The external account number (int) or account ID Guid. (required)
2501        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2502        :return: BillingChargeResponse
2503                 If the method is called asynchronously,
2504                 returns the request thread.
2505        """
2506
2507        all_params = ['account_id', 'include_charges']
2508        all_params.append('callback')
2509        all_params.append('_return_http_data_only')
2510        all_params.append('_preload_content')
2511        all_params.append('_request_timeout')
2512
2513        params = locals()
2514        for key, val in iteritems(params['kwargs']):
2515            if key not in all_params:
2516                raise TypeError(
2517                    "Got an unexpected keyword argument '%s'"
2518                    " to method get_billing_charges" % key
2519                )
2520            params[key] = val
2521        del params['kwargs']
2522        # verify the required parameter 'account_id' is set
2523        if ('account_id' not in params) or (params['account_id'] is None):
2524            raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`")
2525
2526
2527        collection_formats = {}
2528
2529        resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json')
2530        path_params = {}
2531        if 'account_id' in params:
2532            path_params['accountId'] = params['account_id']
2533
2534        query_params = {}
2535        if 'include_charges' in params:
2536            query_params['include_charges'] = params['include_charges']
2537
2538        header_params = {}
2539
2540        form_params = []
2541        local_var_files = {}
2542
2543        body_params = None
2544        # HTTP header `Accept`
2545        header_params['Accept'] = self.api_client.\
2546            select_header_accept(['application/json'])
2547
2548        # Authentication setting
2549        auth_settings = []
2550
2551        return self.api_client.call_api(resource_path, 'GET',
2552                                        path_params,
2553                                        query_params,
2554                                        header_params,
2555                                        body=body_params,
2556                                        post_params=form_params,
2557                                        files=local_var_files,
2558                                        response_type='BillingChargeResponse',
2559                                        auth_settings=auth_settings,
2560                                        callback=params.get('callback'),
2561                                        _return_http_data_only=params.get('_return_http_data_only'),
2562                                        _preload_content=params.get('_preload_content', True),
2563                                        _request_timeout=params.get('_request_timeout'),
2564                                        collection_formats=collection_formats)
2565
2566    def get_brand(self, account_id, brand_id, **kwargs):
2567        """
2568        Get information for a specific brand.
2569        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2570        This method makes a synchronous HTTP request by default. To make an
2571        asynchronous HTTP request, please define a `callback` function
2572        to be invoked when receiving the response.
2573        >>> def callback_function(response):
2574        >>>     pprint(response)
2575        >>>
2576        >>> thread = api.get_brand(account_id, brand_id, callback=callback_function)
2577
2578        :param callback function: The callback function
2579            for asynchronous request. (optional)
2580        :param str account_id: The external account number (int) or account ID Guid. (required)
2581        :param str brand_id: The unique identifier of a brand. (required)
2582        :param str include_external_references:
2583        :param str include_logos:
2584        :return: Brand
2585                 If the method is called asynchronously,
2586                 returns the request thread.
2587        """
2588        kwargs['_return_http_data_only'] = True
2589        if kwargs.get('callback'):
2590            return self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2591        else:
2592            (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2593            return data
2594
2595    def get_brand_with_http_info(self, account_id, brand_id, **kwargs):
2596        """
2597        Get information for a specific brand.
2598        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2599        This method makes a synchronous HTTP request by default. To make an
2600        asynchronous HTTP request, please define a `callback` function
2601        to be invoked when receiving the response.
2602        >>> def callback_function(response):
2603        >>>     pprint(response)
2604        >>>
2605        >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function)
2606
2607        :param callback function: The callback function
2608            for asynchronous request. (optional)
2609        :param str account_id: The external account number (int) or account ID Guid. (required)
2610        :param str brand_id: The unique identifier of a brand. (required)
2611        :param str include_external_references:
2612        :param str include_logos:
2613        :return: Brand
2614                 If the method is called asynchronously,
2615                 returns the request thread.
2616        """
2617
2618        all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos']
2619        all_params.append('callback')
2620        all_params.append('_return_http_data_only')
2621        all_params.append('_preload_content')
2622        all_params.append('_request_timeout')
2623
2624        params = locals()
2625        for key, val in iteritems(params['kwargs']):
2626            if key not in all_params:
2627                raise TypeError(
2628                    "Got an unexpected keyword argument '%s'"
2629                    " to method get_brand" % key
2630                )
2631            params[key] = val
2632        del params['kwargs']
2633        # verify the required parameter 'account_id' is set
2634        if ('account_id' not in params) or (params['account_id'] is None):
2635            raise ValueError("Missing the required parameter `account_id` when calling `get_brand`")
2636        # verify the required parameter 'brand_id' is set
2637        if ('brand_id' not in params) or (params['brand_id'] is None):
2638            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`")
2639
2640
2641        collection_formats = {}
2642
2643        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
2644        path_params = {}
2645        if 'account_id' in params:
2646            path_params['accountId'] = params['account_id']
2647        if 'brand_id' in params:
2648            path_params['brandId'] = params['brand_id']
2649
2650        query_params = {}
2651        if 'include_external_references' in params:
2652            query_params['include_external_references'] = params['include_external_references']
2653        if 'include_logos' in params:
2654            query_params['include_logos'] = params['include_logos']
2655
2656        header_params = {}
2657
2658        form_params = []
2659        local_var_files = {}
2660
2661        body_params = None
2662        # HTTP header `Accept`
2663        header_params['Accept'] = self.api_client.\
2664            select_header_accept(['application/json'])
2665
2666        # Authentication setting
2667        auth_settings = []
2668
2669        return self.api_client.call_api(resource_path, 'GET',
2670                                        path_params,
2671                                        query_params,
2672                                        header_params,
2673                                        body=body_params,
2674                                        post_params=form_params,
2675                                        files=local_var_files,
2676                                        response_type='Brand',
2677                                        auth_settings=auth_settings,
2678                                        callback=params.get('callback'),
2679                                        _return_http_data_only=params.get('_return_http_data_only'),
2680                                        _preload_content=params.get('_preload_content', True),
2681                                        _request_timeout=params.get('_request_timeout'),
2682                                        collection_formats=collection_formats)
2683
2684    def get_brand_export_file(self, account_id, brand_id, **kwargs):
2685        """
2686        Export a specific brand.
2687        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2688        This method makes a synchronous HTTP request by default. To make an
2689        asynchronous HTTP request, please define a `callback` function
2690        to be invoked when receiving the response.
2691        >>> def callback_function(response):
2692        >>>     pprint(response)
2693        >>>
2694        >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function)
2695
2696        :param callback function: The callback function
2697            for asynchronous request. (optional)
2698        :param str account_id: The external account number (int) or account ID Guid. (required)
2699        :param str brand_id: The unique identifier of a brand. (required)
2700        :return: None
2701                 If the method is called asynchronously,
2702                 returns the request thread.
2703        """
2704        kwargs['_return_http_data_only'] = True
2705        if kwargs.get('callback'):
2706            return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2707        else:
2708            (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2709            return data
2710
2711    def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs):
2712        """
2713        Export a specific brand.
2714        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2715        This method makes a synchronous HTTP request by default. To make an
2716        asynchronous HTTP request, please define a `callback` function
2717        to be invoked when receiving the response.
2718        >>> def callback_function(response):
2719        >>>     pprint(response)
2720        >>>
2721        >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
2722
2723        :param callback function: The callback function
2724            for asynchronous request. (optional)
2725        :param str account_id: The external account number (int) or account ID Guid. (required)
2726        :param str brand_id: The unique identifier of a brand. (required)
2727        :return: None
2728                 If the method is called asynchronously,
2729                 returns the request thread.
2730        """
2731
2732        all_params = ['account_id', 'brand_id']
2733        all_params.append('callback')
2734        all_params.append('_return_http_data_only')
2735        all_params.append('_preload_content')
2736        all_params.append('_request_timeout')
2737
2738        params = locals()
2739        for key, val in iteritems(params['kwargs']):
2740            if key not in all_params:
2741                raise TypeError(
2742                    "Got an unexpected keyword argument '%s'"
2743                    " to method get_brand_export_file" % key
2744                )
2745            params[key] = val
2746        del params['kwargs']
2747        # verify the required parameter 'account_id' is set
2748        if ('account_id' not in params) or (params['account_id'] is None):
2749            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`")
2750        # verify the required parameter 'brand_id' is set
2751        if ('brand_id' not in params) or (params['brand_id'] is None):
2752            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`")
2753
2754
2755        collection_formats = {}
2756
2757        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json')
2758        path_params = {}
2759        if 'account_id' in params:
2760            path_params['accountId'] = params['account_id']
2761        if 'brand_id' in params:
2762            path_params['brandId'] = params['brand_id']
2763
2764        query_params = {}
2765
2766        header_params = {}
2767
2768        form_params = []
2769        local_var_files = {}
2770
2771        body_params = None
2772        # HTTP header `Accept`
2773        header_params['Accept'] = self.api_client.\
2774            select_header_accept(['application/json'])
2775
2776        # Authentication setting
2777        auth_settings = []
2778
2779        return self.api_client.call_api(resource_path, 'GET',
2780                                        path_params,
2781                                        query_params,
2782                                        header_params,
2783                                        body=body_params,
2784                                        post_params=form_params,
2785                                        files=local_var_files,
2786                                        response_type=None,
2787                                        auth_settings=auth_settings,
2788                                        callback=params.get('callback'),
2789                                        _return_http_data_only=params.get('_return_http_data_only'),
2790                                        _preload_content=params.get('_preload_content', True),
2791                                        _request_timeout=params.get('_request_timeout'),
2792                                        collection_formats=collection_formats)
2793
2794    def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
2795        """
2796        Obtains the specified image for a brand.
2797        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2798        This method makes a synchronous HTTP request by default. To make an
2799        asynchronous HTTP request, please define a `callback` function
2800        to be invoked when receiving the response.
2801        >>> def callback_function(response):
2802        >>>     pprint(response)
2803        >>>
2804        >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
2805
2806        :param callback function: The callback function
2807            for asynchronous request. (optional)
2808        :param str account_id: The external account number (int) or account ID Guid. (required)
2809        :param str brand_id: The unique identifier of a brand. (required)
2810        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2811        :return: file
2812                 If the method is called asynchronously,
2813                 returns the request thread.
2814        """
2815        kwargs['_return_http_data_only'] = True
2816        if kwargs.get('callback'):
2817            return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2818        else:
2819            (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2820            return data
2821
2822    def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
2823        """
2824        Obtains the specified image for a brand.
2825        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2826        This method makes a synchronous HTTP request by default. To make an
2827        asynchronous HTTP request, please define a `callback` function
2828        to be invoked when receiving the response.
2829        >>> def callback_function(response):
2830        >>>     pprint(response)
2831        >>>
2832        >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
2833
2834        :param callback function: The callback function
2835            for asynchronous request. (optional)
2836        :param str account_id: The external account number (int) or account ID Guid. (required)
2837        :param str brand_id: The unique identifier of a brand. (required)
2838        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2839        :return: file
2840                 If the method is called asynchronously,
2841                 returns the request thread.
2842        """
2843
2844        all_params = ['account_id', 'brand_id', 'logo_type']
2845        all_params.append('callback')
2846        all_params.append('_return_http_data_only')
2847        all_params.append('_preload_content')
2848        all_params.append('_request_timeout')
2849
2850        params = locals()
2851        for key, val in iteritems(params['kwargs']):
2852            if key not in all_params:
2853                raise TypeError(
2854                    "Got an unexpected keyword argument '%s'"
2855                    " to method get_brand_logo_by_type" % key
2856                )
2857            params[key] = val
2858        del params['kwargs']
2859        # verify the required parameter 'account_id' is set
2860        if ('account_id' not in params) or (params['account_id'] is None):
2861            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`")
2862        # verify the required parameter 'brand_id' is set
2863        if ('brand_id' not in params) or (params['brand_id'] is None):
2864            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`")
2865        # verify the required parameter 'logo_type' is set
2866        if ('logo_type' not in params) or (params['logo_type'] is None):
2867            raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`")
2868
2869
2870        collection_formats = {}
2871
2872        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
2873        path_params = {}
2874        if 'account_id' in params:
2875            path_params['accountId'] = params['account_id']
2876        if 'brand_id' in params:
2877            path_params['brandId'] = params['brand_id']
2878        if 'logo_type' in params:
2879            path_params['logoType'] = params['logo_type']
2880
2881        query_params = {}
2882
2883        header_params = {}
2884
2885        form_params = []
2886        local_var_files = {}
2887
2888        body_params = None
2889        # HTTP header `Accept`
2890        header_params['Accept'] = self.api_client.\
2891            select_header_accept(['image/png'])
2892
2893        # Authentication setting
2894        auth_settings = []
2895
2896        return self.api_client.call_api(resource_path, 'GET',
2897                                        path_params,
2898                                        query_params,
2899                                        header_params,
2900                                        body=body_params,
2901                                        post_params=form_params,
2902                                        files=local_var_files,
2903                                        response_type='file',
2904                                        auth_settings=auth_settings,
2905                                        callback=params.get('callback'),
2906                                        _return_http_data_only=params.get('_return_http_data_only'),
2907                                        _preload_content=params.get('_preload_content', True),
2908                                        _request_timeout=params.get('_request_timeout'),
2909                                        collection_formats=collection_formats)
2910
2911    def get_brand_resources(self, account_id, brand_id, **kwargs):
2912        """
2913        Returns the specified account's list of branding resources (metadata).
2914        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2915        This method makes a synchronous HTTP request by default. To make an
2916        asynchronous HTTP request, please define a `callback` function
2917        to be invoked when receiving the response.
2918        >>> def callback_function(response):
2919        >>>     pprint(response)
2920        >>>
2921        >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function)
2922
2923        :param callback function: The callback function
2924            for asynchronous request. (optional)
2925        :param str account_id: The external account number (int) or account ID Guid. (required)
2926        :param str brand_id: The unique identifier of a brand. (required)
2927        :return: BrandResourcesList
2928                 If the method is called asynchronously,
2929                 returns the request thread.
2930        """
2931        kwargs['_return_http_data_only'] = True
2932        if kwargs.get('callback'):
2933            return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2934        else:
2935            (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2936            return data
2937
2938    def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs):
2939        """
2940        Returns the specified account's list of branding resources (metadata).
2941        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2942        This method makes a synchronous HTTP request by default. To make an
2943        asynchronous HTTP request, please define a `callback` function
2944        to be invoked when receiving the response.
2945        >>> def callback_function(response):
2946        >>>     pprint(response)
2947        >>>
2948        >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
2949
2950        :param callback function: The callback function
2951            for asynchronous request. (optional)
2952        :param str account_id: The external account number (int) or account ID Guid. (required)
2953        :param str brand_id: The unique identifier of a brand. (required)
2954        :return: BrandResourcesList
2955                 If the method is called asynchronously,
2956                 returns the request thread.
2957        """
2958
2959        all_params = ['account_id', 'brand_id']
2960        all_params.append('callback')
2961        all_params.append('_return_http_data_only')
2962        all_params.append('_preload_content')
2963        all_params.append('_request_timeout')
2964
2965        params = locals()
2966        for key, val in iteritems(params['kwargs']):
2967            if key not in all_params:
2968                raise TypeError(
2969                    "Got an unexpected keyword argument '%s'"
2970                    " to method get_brand_resources" % key
2971                )
2972            params[key] = val
2973        del params['kwargs']
2974        # verify the required parameter 'account_id' is set
2975        if ('account_id' not in params) or (params['account_id'] is None):
2976            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`")
2977        # verify the required parameter 'brand_id' is set
2978        if ('brand_id' not in params) or (params['brand_id'] is None):
2979            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`")
2980
2981
2982        collection_formats = {}
2983
2984        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json')
2985        path_params = {}
2986        if 'account_id' in params:
2987            path_params['accountId'] = params['account_id']
2988        if 'brand_id' in params:
2989            path_params['brandId'] = params['brand_id']
2990
2991        query_params = {}
2992
2993        header_params = {}
2994
2995        form_params = []
2996        local_var_files = {}
2997
2998        body_params = None
2999        # HTTP header `Accept`
3000        header_params['Accept'] = self.api_client.\
3001            select_header_accept(['application/json'])
3002
3003        # Authentication setting
3004        auth_settings = []
3005
3006        return self.api_client.call_api(resource_path, 'GET',
3007                                        path_params,
3008                                        query_params,
3009                                        header_params,
3010                                        body=body_params,
3011                                        post_params=form_params,
3012                                        files=local_var_files,
3013                                        response_type='BrandResourcesList',
3014                                        auth_settings=auth_settings,
3015                                        callback=params.get('callback'),
3016                                        _return_http_data_only=params.get('_return_http_data_only'),
3017                                        _preload_content=params.get('_preload_content', True),
3018                                        _request_timeout=params.get('_request_timeout'),
3019                                        collection_formats=collection_formats)
3020
3021    def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs):
3022        """
3023        Returns the specified branding resource file.
3024        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3025        This method makes a synchronous HTTP request by default. To make an
3026        asynchronous HTTP request, please define a `callback` function
3027        to be invoked when receiving the response.
3028        >>> def callback_function(response):
3029        >>>     pprint(response)
3030        >>>
3031        >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
3032
3033        :param callback function: The callback function
3034            for asynchronous request. (optional)
3035        :param str account_id: The external account number (int) or account ID Guid. (required)
3036        :param str brand_id: The unique identifier of a brand. (required)
3037        :param str resource_content_type: (required)
3038        :param str langcode:
3039        :param str return_master:
3040        :return: None
3041                 If the method is called asynchronously,
3042                 returns the request thread.
3043        """
3044        kwargs['_return_http_data_only'] = True
3045        if kwargs.get('callback'):
3046            return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3047        else:
3048            (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3049            return data
3050
3051    def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs):
3052        """
3053        Returns the specified branding resource file.
3054        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3055        This method makes a synchronous HTTP request by default. To make an
3056        asynchronous HTTP request, please define a `callback` function
3057        to be invoked when receiving the response.
3058        >>> def callback_function(response):
3059        >>>     pprint(response)
3060        >>>
3061        >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
3062
3063        :param callback function: The callback function
3064            for asynchronous request. (optional)
3065        :param str account_id: The external account number (int) or account ID Guid. (required)
3066        :param str brand_id: The unique identifier of a brand. (required)
3067        :param str resource_content_type: (required)
3068        :param str langcode:
3069        :param str return_master:
3070        :return: None
3071                 If the method is called asynchronously,
3072                 returns the request thread.
3073        """
3074
3075        all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master']
3076        all_params.append('callback')
3077        all_params.append('_return_http_data_only')
3078        all_params.append('_preload_content')
3079        all_params.append('_request_timeout')
3080
3081        params = locals()
3082        for key, val in iteritems(params['kwargs']):
3083            if key not in all_params:
3084                raise TypeError(
3085                    "Got an unexpected keyword argument '%s'"
3086                    " to method get_brand_resources_by_content_type" % key
3087                )
3088            params[key] = val
3089        del params['kwargs']
3090        # verify the required parameter 'account_id' is set
3091        if ('account_id' not in params) or (params['account_id'] is None):
3092            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`")
3093        # verify the required parameter 'brand_id' is set
3094        if ('brand_id' not in params) or (params['brand_id'] is None):
3095            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`")
3096        # verify the required parameter 'resource_content_type' is set
3097        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
3098            raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`")
3099
3100
3101        collection_formats = {}
3102
3103        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
3104        path_params = {}
3105        if 'account_id' in params:
3106            path_params['accountId'] = params['account_id']
3107        if 'brand_id' in params:
3108            path_params['brandId'] = params['brand_id']
3109        if 'resource_content_type' in params:
3110            path_params['resourceContentType'] = params['resource_content_type']
3111
3112        query_params = {}
3113        if 'langcode' in params:
3114            query_params['langcode'] = params['langcode']
3115        if 'return_master' in params:
3116            query_params['return_master'] = params['return_master']
3117
3118        header_params = {}
3119
3120        form_params = []
3121        local_var_files = {}
3122
3123        body_params = None
3124        # HTTP header `Accept`
3125        header_params['Accept'] = self.api_client.\
3126            select_header_accept(['application/json'])
3127
3128        # Authentication setting
3129        auth_settings = []
3130
3131        return self.api_client.call_api(resource_path, 'GET',
3132                                        path_params,
3133                                        query_params,
3134                                        header_params,
3135                                        body=body_params,
3136                                        post_params=form_params,
3137                                        files=local_var_files,
3138                                        response_type=None,
3139                                        auth_settings=auth_settings,
3140                                        callback=params.get('callback'),
3141                                        _return_http_data_only=params.get('_return_http_data_only'),
3142                                        _preload_content=params.get('_preload_content', True),
3143                                        _request_timeout=params.get('_request_timeout'),
3144                                        collection_formats=collection_formats)
3145
3146    def get_consumer_disclosure(self, account_id, lang_code, **kwargs):
3147        """
3148        Gets the Electronic Record and Signature Disclosure.
3149        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3150        This method makes a synchronous HTTP request by default. To make an
3151        asynchronous HTTP request, please define a `callback` function
3152        to be invoked when receiving the response.
3153        >>> def callback_function(response):
3154        >>>     pprint(response)
3155        >>>
3156        >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function)
3157
3158        :param callback function: The callback function
3159            for asynchronous request. (optional)
3160        :param str account_id: The external account number (int) or account ID Guid. (required)
3161        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3162        :return: ConsumerDisclosure
3163                 If the method is called asynchronously,
3164                 returns the request thread.
3165        """
3166        kwargs['_return_http_data_only'] = True
3167        if kwargs.get('callback'):
3168            return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3169        else:
3170            (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3171            return data
3172
3173    def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
3174        """
3175        Gets the Electronic Record and Signature Disclosure.
3176        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3177        This method makes a synchronous HTTP request by default. To make an
3178        asynchronous HTTP request, please define a `callback` function
3179        to be invoked when receiving the response.
3180        >>> def callback_function(response):
3181        >>>     pprint(response)
3182        >>>
3183        >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
3184
3185        :param callback function: The callback function
3186            for asynchronous request. (optional)
3187        :param str account_id: The external account number (int) or account ID Guid. (required)
3188        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3189        :return: ConsumerDisclosure
3190                 If the method is called asynchronously,
3191                 returns the request thread.
3192        """
3193
3194        all_params = ['account_id', 'lang_code']
3195        all_params.append('callback')
3196        all_params.append('_return_http_data_only')
3197        all_params.append('_preload_content')
3198        all_params.append('_request_timeout')
3199
3200        params = locals()
3201        for key, val in iteritems(params['kwargs']):
3202            if key not in all_params:
3203                raise TypeError(
3204                    "Got an unexpected keyword argument '%s'"
3205                    " to method get_consumer_disclosure" % key
3206                )
3207            params[key] = val
3208        del params['kwargs']
3209        # verify the required parameter 'account_id' is set
3210        if ('account_id' not in params) or (params['account_id'] is None):
3211            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`")
3212        # verify the required parameter 'lang_code' is set
3213        if ('lang_code' not in params) or (params['lang_code'] is None):
3214            raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`")
3215
3216
3217        collection_formats = {}
3218
3219        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
3220        path_params = {}
3221        if 'account_id' in params:
3222            path_params['accountId'] = params['account_id']
3223        if 'lang_code' in params:
3224            path_params['langCode'] = params['lang_code']
3225
3226        query_params = {}
3227
3228        header_params = {}
3229
3230        form_params = []
3231        local_var_files = {}
3232
3233        body_params = None
3234        # HTTP header `Accept`
3235        header_params['Accept'] = self.api_client.\
3236            select_header_accept(['application/json'])
3237
3238        # Authentication setting
3239        auth_settings = []
3240
3241        return self.api_client.call_api(resource_path, 'GET',
3242                                        path_params,
3243                                        query_params,
3244                                        header_params,
3245                                        body=body_params,
3246                                        post_params=form_params,
3247                                        files=local_var_files,
3248                                        response_type='ConsumerDisclosure',
3249                                        auth_settings=auth_settings,
3250                                        callback=params.get('callback'),
3251                                        _return_http_data_only=params.get('_return_http_data_only'),
3252                                        _preload_content=params.get('_preload_content', True),
3253                                        _request_timeout=params.get('_request_timeout'),
3254                                        collection_formats=collection_formats)
3255
3256    def get_consumer_disclosure_default(self, account_id, **kwargs):
3257        """
3258        Gets the Electronic Record and Signature Disclosure for the account.
3259        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3260        This method makes a synchronous HTTP request by default. To make an
3261        asynchronous HTTP request, please define a `callback` function
3262        to be invoked when receiving the response.
3263        >>> def callback_function(response):
3264        >>>     pprint(response)
3265        >>>
3266        >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function)
3267
3268        :param callback function: The callback function
3269            for asynchronous request. (optional)
3270        :param str account_id: The external account number (int) or account ID Guid. (required)
3271        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3272        :return: ConsumerDisclosure
3273                 If the method is called asynchronously,
3274                 returns the request thread.
3275        """
3276        kwargs['_return_http_data_only'] = True
3277        if kwargs.get('callback'):
3278            return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3279        else:
3280            (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3281            return data
3282
3283    def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs):
3284        """
3285        Gets the Electronic Record and Signature Disclosure for the account.
3286        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3287        This method makes a synchronous HTTP request by default. To make an
3288        asynchronous HTTP request, please define a `callback` function
3289        to be invoked when receiving the response.
3290        >>> def callback_function(response):
3291        >>>     pprint(response)
3292        >>>
3293        >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function)
3294
3295        :param callback function: The callback function
3296            for asynchronous request. (optional)
3297        :param str account_id: The external account number (int) or account ID Guid. (required)
3298        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3299        :return: ConsumerDisclosure
3300                 If the method is called asynchronously,
3301                 returns the request thread.
3302        """
3303
3304        all_params = ['account_id', 'lang_code']
3305        all_params.append('callback')
3306        all_params.append('_return_http_data_only')
3307        all_params.append('_preload_content')
3308        all_params.append('_request_timeout')
3309
3310        params = locals()
3311        for key, val in iteritems(params['kwargs']):
3312            if key not in all_params:
3313                raise TypeError(
3314                    "Got an unexpected keyword argument '%s'"
3315                    " to method get_consumer_disclosure_default" % key
3316                )
3317            params[key] = val
3318        del params['kwargs']
3319        # verify the required parameter 'account_id' is set
3320        if ('account_id' not in params) or (params['account_id'] is None):
3321            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`")
3322
3323
3324        collection_formats = {}
3325
3326        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json')
3327        path_params = {}
3328        if 'account_id' in params:
3329            path_params['accountId'] = params['account_id']
3330
3331        query_params = {}
3332        if 'lang_code' in params:
3333            query_params['langCode'] = params['lang_code']
3334
3335        header_params = {}
3336
3337        form_params = []
3338        local_var_files = {}
3339
3340        body_params = None
3341        # HTTP header `Accept`
3342        header_params['Accept'] = self.api_client.\
3343            select_header_accept(['application/json'])
3344
3345        # Authentication setting
3346        auth_settings = []
3347
3348        return self.api_client.call_api(resource_path, 'GET',
3349                                        path_params,
3350                                        query_params,
3351                                        header_params,
3352                                        body=body_params,
3353                                        post_params=form_params,
3354                                        files=local_var_files,
3355                                        response_type='ConsumerDisclosure',
3356                                        auth_settings=auth_settings,
3357                                        callback=params.get('callback'),
3358                                        _return_http_data_only=params.get('_return_http_data_only'),
3359                                        _preload_content=params.get('_preload_content', True),
3360                                        _request_timeout=params.get('_request_timeout'),
3361                                        collection_formats=collection_formats)
3362
3363    def get_e_note_configuration(self, account_id, **kwargs):
3364        """
3365        Returns the configuration information for the eNote eOriginal integration.
3366        
3367        This method makes a synchronous HTTP request by default. To make an
3368        asynchronous HTTP request, please define a `callback` function
3369        to be invoked when receiving the response.
3370        >>> def callback_function(response):
3371        >>>     pprint(response)
3372        >>>
3373        >>> thread = api.get_e_note_configuration(account_id, callback=callback_function)
3374
3375        :param callback function: The callback function
3376            for asynchronous request. (optional)
3377        :param str account_id: The external account number (int) or account ID Guid. (required)
3378        :return: ENoteConfiguration
3379                 If the method is called asynchronously,
3380                 returns the request thread.
3381        """
3382        kwargs['_return_http_data_only'] = True
3383        if kwargs.get('callback'):
3384            return self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3385        else:
3386            (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3387            return data
3388
3389    def get_e_note_configuration_with_http_info(self, account_id, **kwargs):
3390        """
3391        Returns the configuration information for the eNote eOriginal integration.
3392        
3393        This method makes a synchronous HTTP request by default. To make an
3394        asynchronous HTTP request, please define a `callback` function
3395        to be invoked when receiving the response.
3396        >>> def callback_function(response):
3397        >>>     pprint(response)
3398        >>>
3399        >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function)
3400
3401        :param callback function: The callback function
3402            for asynchronous request. (optional)
3403        :param str account_id: The external account number (int) or account ID Guid. (required)
3404        :return: ENoteConfiguration
3405                 If the method is called asynchronously,
3406                 returns the request thread.
3407        """
3408
3409        all_params = ['account_id']
3410        all_params.append('callback')
3411        all_params.append('_return_http_data_only')
3412        all_params.append('_preload_content')
3413        all_params.append('_request_timeout')
3414
3415        params = locals()
3416        for key, val in iteritems(params['kwargs']):
3417            if key not in all_params:
3418                raise TypeError(
3419                    "Got an unexpected keyword argument '%s'"
3420                    " to method get_e_note_configuration" % key
3421                )
3422            params[key] = val
3423        del params['kwargs']
3424        # verify the required parameter 'account_id' is set
3425        if ('account_id' not in params) or (params['account_id'] is None):
3426            raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`")
3427
3428
3429        collection_formats = {}
3430
3431        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
3432        path_params = {}
3433        if 'account_id' in params:
3434            path_params['accountId'] = params['account_id']
3435
3436        query_params = {}
3437
3438        header_params = {}
3439
3440        form_params = []
3441        local_var_files = {}
3442
3443        body_params = None
3444        # HTTP header `Accept`
3445        header_params['Accept'] = self.api_client.\
3446            select_header_accept(['application/json'])
3447
3448        # Authentication setting
3449        auth_settings = []
3450
3451        return self.api_client.call_api(resource_path, 'GET',
3452                                        path_params,
3453                                        query_params,
3454                                        header_params,
3455                                        body=body_params,
3456                                        post_params=form_params,
3457                                        files=local_var_files,
3458                                        response_type='ENoteConfiguration',
3459                                        auth_settings=auth_settings,
3460                                        callback=params.get('callback'),
3461                                        _return_http_data_only=params.get('_return_http_data_only'),
3462                                        _preload_content=params.get('_preload_content', True),
3463                                        _request_timeout=params.get('_request_timeout'),
3464                                        collection_formats=collection_formats)
3465
3466    def get_envelope_purge_configuration(self, account_id, **kwargs):
3467        """
3468        Select envelope purge configuration.
3469        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3470        This method makes a synchronous HTTP request by default. To make an
3471        asynchronous HTTP request, please define a `callback` function
3472        to be invoked when receiving the response.
3473        >>> def callback_function(response):
3474        >>>     pprint(response)
3475        >>>
3476        >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function)
3477
3478        :param callback function: The callback function
3479            for asynchronous request. (optional)
3480        :param str account_id: The external account number (int) or account ID Guid. (required)
3481        :return: EnvelopePurgeConfiguration
3482                 If the method is called asynchronously,
3483                 returns the request thread.
3484        """
3485        kwargs['_return_http_data_only'] = True
3486        if kwargs.get('callback'):
3487            return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3488        else:
3489            (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3490            return data
3491
3492    def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
3493        """
3494        Select envelope purge configuration.
3495        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3496        This method makes a synchronous HTTP request by default. To make an
3497        asynchronous HTTP request, please define a `callback` function
3498        to be invoked when receiving the response.
3499        >>> def callback_function(response):
3500        >>>     pprint(response)
3501        >>>
3502        >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
3503
3504        :param callback function: The callback function
3505            for asynchronous request. (optional)
3506        :param str account_id: The external account number (int) or account ID Guid. (required)
3507        :return: EnvelopePurgeConfiguration
3508                 If the method is called asynchronously,
3509                 returns the request thread.
3510        """
3511
3512        all_params = ['account_id']
3513        all_params.append('callback')
3514        all_params.append('_return_http_data_only')
3515        all_params.append('_preload_content')
3516        all_params.append('_request_timeout')
3517
3518        params = locals()
3519        for key, val in iteritems(params['kwargs']):
3520            if key not in all_params:
3521                raise TypeError(
3522                    "Got an unexpected keyword argument '%s'"
3523                    " to method get_envelope_purge_configuration" % key
3524                )
3525            params[key] = val
3526        del params['kwargs']
3527        # verify the required parameter 'account_id' is set
3528        if ('account_id' not in params) or (params['account_id'] is None):
3529            raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`")
3530
3531
3532        collection_formats = {}
3533
3534        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
3535        path_params = {}
3536        if 'account_id' in params:
3537            path_params['accountId'] = params['account_id']
3538
3539        query_params = {}
3540
3541        header_params = {}
3542
3543        form_params = []
3544        local_var_files = {}
3545
3546        body_params = None
3547        # HTTP header `Accept`
3548        header_params['Accept'] = self.api_client.\
3549            select_header_accept(['application/json'])
3550
3551        # Authentication setting
3552        auth_settings = []
3553
3554        return self.api_client.call_api(resource_path, 'GET',
3555                                        path_params,
3556                                        query_params,
3557                                        header_params,
3558                                        body=body_params,
3559                                        post_params=form_params,
3560                                        files=local_var_files,
3561                                        response_type='EnvelopePurgeConfiguration',
3562                                        auth_settings=auth_settings,
3563                                        callback=params.get('callback'),
3564                                        _return_http_data_only=params.get('_return_http_data_only'),
3565                                        _preload_content=params.get('_preload_content', True),
3566                                        _request_timeout=params.get('_request_timeout'),
3567                                        collection_formats=collection_formats)
3568
3569    def get_favorite_templates(self, account_id, **kwargs):
3570        """
3571        Retrieves the list of favorited templates for this caller
3572        
3573        This method makes a synchronous HTTP request by default. To make an
3574        asynchronous HTTP request, please define a `callback` function
3575        to be invoked when receiving the response.
3576        >>> def callback_function(response):
3577        >>>     pprint(response)
3578        >>>
3579        >>> thread = api.get_favorite_templates(account_id, callback=callback_function)
3580
3581        :param callback function: The callback function
3582            for asynchronous request. (optional)
3583        :param str account_id: The external account number (int) or account ID Guid. (required)
3584        :return: FavoriteTemplatesInfo
3585                 If the method is called asynchronously,
3586                 returns the request thread.
3587        """
3588        kwargs['_return_http_data_only'] = True
3589        if kwargs.get('callback'):
3590            return self.get_favorite_templates_with_http_info(account_id, **kwargs)
3591        else:
3592            (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs)
3593            return data
3594
3595    def get_favorite_templates_with_http_info(self, account_id, **kwargs):
3596        """
3597        Retrieves the list of favorited templates for this caller
3598        
3599        This method makes a synchronous HTTP request by default. To make an
3600        asynchronous HTTP request, please define a `callback` function
3601        to be invoked when receiving the response.
3602        >>> def callback_function(response):
3603        >>>     pprint(response)
3604        >>>
3605        >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function)
3606
3607        :param callback function: The callback function
3608            for asynchronous request. (optional)
3609        :param str account_id: The external account number (int) or account ID Guid. (required)
3610        :return: FavoriteTemplatesInfo
3611                 If the method is called asynchronously,
3612                 returns the request thread.
3613        """
3614
3615        all_params = ['account_id']
3616        all_params.append('callback')
3617        all_params.append('_return_http_data_only')
3618        all_params.append('_preload_content')
3619        all_params.append('_request_timeout')
3620
3621        params = locals()
3622        for key, val in iteritems(params['kwargs']):
3623            if key not in all_params:
3624                raise TypeError(
3625                    "Got an unexpected keyword argument '%s'"
3626                    " to method get_favorite_templates" % key
3627                )
3628            params[key] = val
3629        del params['kwargs']
3630        # verify the required parameter 'account_id' is set
3631        if ('account_id' not in params) or (params['account_id'] is None):
3632            raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`")
3633
3634
3635        collection_formats = {}
3636
3637        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
3638        path_params = {}
3639        if 'account_id' in params:
3640            path_params['accountId'] = params['account_id']
3641
3642        query_params = {}
3643
3644        header_params = {}
3645
3646        form_params = []
3647        local_var_files = {}
3648
3649        body_params = None
3650        # HTTP header `Accept`
3651        header_params['Accept'] = self.api_client.\
3652            select_header_accept(['application/json'])
3653
3654        # Authentication setting
3655        auth_settings = []
3656
3657        return self.api_client.call_api(resource_path, 'GET',
3658                                        path_params,
3659                                        query_params,
3660                                        header_params,
3661                                        body=body_params,
3662                                        post_params=form_params,
3663                                        files=local_var_files,
3664                                        response_type='FavoriteTemplatesInfo',
3665                                        auth_settings=auth_settings,
3666                                        callback=params.get('callback'),
3667                                        _return_http_data_only=params.get('_return_http_data_only'),
3668                                        _preload_content=params.get('_preload_content', True),
3669                                        _request_timeout=params.get('_request_timeout'),
3670                                        collection_formats=collection_formats)
3671
3672    def get_notification_defaults(self, account_id, **kwargs):
3673        """
3674        Returns default user level settings for a specified account
3675        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3676        This method makes a synchronous HTTP request by default. To make an
3677        asynchronous HTTP request, please define a `callback` function
3678        to be invoked when receiving the response.
3679        >>> def callback_function(response):
3680        >>>     pprint(response)
3681        >>>
3682        >>> thread = api.get_notification_defaults(account_id, callback=callback_function)
3683
3684        :param callback function: The callback function
3685            for asynchronous request. (optional)
3686        :param str account_id: The external account number (int) or account ID Guid. (required)
3687        :return: NotificationDefaults
3688                 If the method is called asynchronously,
3689                 returns the request thread.
3690        """
3691        kwargs['_return_http_data_only'] = True
3692        if kwargs.get('callback'):
3693            return self.get_notification_defaults_with_http_info(account_id, **kwargs)
3694        else:
3695            (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs)
3696            return data
3697
3698    def get_notification_defaults_with_http_info(self, account_id, **kwargs):
3699        """
3700        Returns default user level settings for a specified account
3701        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3702        This method makes a synchronous HTTP request by default. To make an
3703        asynchronous HTTP request, please define a `callback` function
3704        to be invoked when receiving the response.
3705        >>> def callback_function(response):
3706        >>>     pprint(response)
3707        >>>
3708        >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function)
3709
3710        :param callback function: The callback function
3711            for asynchronous request. (optional)
3712        :param str account_id: The external account number (int) or account ID Guid. (required)
3713        :return: NotificationDefaults
3714                 If the method is called asynchronously,
3715                 returns the request thread.
3716        """
3717
3718        all_params = ['account_id']
3719        all_params.append('callback')
3720        all_params.append('_return_http_data_only')
3721        all_params.append('_preload_content')
3722        all_params.append('_request_timeout')
3723
3724        params = locals()
3725        for key, val in iteritems(params['kwargs']):
3726            if key not in all_params:
3727                raise TypeError(
3728                    "Got an unexpected keyword argument '%s'"
3729                    " to method get_notification_defaults" % key
3730                )
3731            params[key] = val
3732        del params['kwargs']
3733        # verify the required parameter 'account_id' is set
3734        if ('account_id' not in params) or (params['account_id'] is None):
3735            raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`")
3736
3737
3738        collection_formats = {}
3739
3740        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
3741        path_params = {}
3742        if 'account_id' in params:
3743            path_params['accountId'] = params['account_id']
3744
3745        query_params = {}
3746
3747        header_params = {}
3748
3749        form_params = []
3750        local_var_files = {}
3751
3752        body_params = None
3753        # HTTP header `Accept`
3754        header_params['Accept'] = self.api_client.\
3755            select_header_accept(['application/json'])
3756
3757        # Authentication setting
3758        auth_settings = []
3759
3760        return self.api_client.call_api(resource_path, 'GET',
3761                                        path_params,
3762                                        query_params,
3763                                        header_params,
3764                                        body=body_params,
3765                                        post_params=form_params,
3766                                        files=local_var_files,
3767                                        response_type='NotificationDefaults',
3768                                        auth_settings=auth_settings,
3769                                        callback=params.get('callback'),
3770                                        _return_http_data_only=params.get('_return_http_data_only'),
3771                                        _preload_content=params.get('_preload_content', True),
3772                                        _request_timeout=params.get('_request_timeout'),
3773                                        collection_formats=collection_formats)
3774
3775    def get_password_rules(self, account_id, **kwargs):
3776        """
3777        Get the password rules
3778        This method retrieves the password rules for an account.
3779        This method makes a synchronous HTTP request by default. To make an
3780        asynchronous HTTP request, please define a `callback` function
3781        to be invoked when receiving the response.
3782        >>> def callback_function(response):
3783        >>>     pprint(response)
3784        >>>
3785        >>> thread = api.get_password_rules(account_id, callback=callback_function)
3786
3787        :param callback function: The callback function
3788            for asynchronous request. (optional)
3789        :param str account_id: The external account number (int) or account ID Guid. (required)
3790        :return: AccountPasswordRules
3791                 If the method is called asynchronously,
3792                 returns the request thread.
3793        """
3794        kwargs['_return_http_data_only'] = True
3795        if kwargs.get('callback'):
3796            return self.get_password_rules_with_http_info(account_id, **kwargs)
3797        else:
3798            (data) = self.get_password_rules_with_http_info(account_id, **kwargs)
3799            return data
3800
3801    def get_password_rules_with_http_info(self, account_id, **kwargs):
3802        """
3803        Get the password rules
3804        This method retrieves the password rules for an account.
3805        This method makes a synchronous HTTP request by default. To make an
3806        asynchronous HTTP request, please define a `callback` function
3807        to be invoked when receiving the response.
3808        >>> def callback_function(response):
3809        >>>     pprint(response)
3810        >>>
3811        >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function)
3812
3813        :param callback function: The callback function
3814            for asynchronous request. (optional)
3815        :param str account_id: The external account number (int) or account ID Guid. (required)
3816        :return: AccountPasswordRules
3817                 If the method is called asynchronously,
3818                 returns the request thread.
3819        """
3820
3821        all_params = ['account_id']
3822        all_params.append('callback')
3823        all_params.append('_return_http_data_only')
3824        all_params.append('_preload_content')
3825        all_params.append('_request_timeout')
3826
3827        params = locals()
3828        for key, val in iteritems(params['kwargs']):
3829            if key not in all_params:
3830                raise TypeError(
3831                    "Got an unexpected keyword argument '%s'"
3832                    " to method get_password_rules" % key
3833                )
3834            params[key] = val
3835        del params['kwargs']
3836        # verify the required parameter 'account_id' is set
3837        if ('account_id' not in params) or (params['account_id'] is None):
3838            raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`")
3839
3840
3841        collection_formats = {}
3842
3843        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
3844        path_params = {}
3845        if 'account_id' in params:
3846            path_params['accountId'] = params['account_id']
3847
3848        query_params = {}
3849
3850        header_params = {}
3851
3852        form_params = []
3853        local_var_files = {}
3854
3855        body_params = None
3856        # HTTP header `Accept`
3857        header_params['Accept'] = self.api_client.\
3858            select_header_accept(['application/json'])
3859
3860        # Authentication setting
3861        auth_settings = []
3862
3863        return self.api_client.call_api(resource_path, 'GET',
3864                                        path_params,
3865                                        query_params,
3866                                        header_params,
3867                                        body=body_params,
3868                                        post_params=form_params,
3869                                        files=local_var_files,
3870                                        response_type='AccountPasswordRules',
3871                                        auth_settings=auth_settings,
3872                                        callback=params.get('callback'),
3873                                        _return_http_data_only=params.get('_return_http_data_only'),
3874                                        _preload_content=params.get('_preload_content', True),
3875                                        _request_timeout=params.get('_request_timeout'),
3876                                        collection_formats=collection_formats)
3877
3878    def get_password_rules_0(self, **kwargs):
3879        """
3880        Get membership account password rules
3881        
3882        This method makes a synchronous HTTP request by default. To make an
3883        asynchronous HTTP request, please define a `callback` function
3884        to be invoked when receiving the response.
3885        >>> def callback_function(response):
3886        >>>     pprint(response)
3887        >>>
3888        >>> thread = api.get_password_rules_0(callback=callback_function)
3889
3890        :param callback function: The callback function
3891            for asynchronous request. (optional)
3892        :return: UserPasswordRules
3893                 If the method is called asynchronously,
3894                 returns the request thread.
3895        """
3896        kwargs['_return_http_data_only'] = True
3897        if kwargs.get('callback'):
3898            return self.get_password_rules_0_with_http_info(**kwargs)
3899        else:
3900            (data) = self.get_password_rules_0_with_http_info(**kwargs)
3901            return data
3902
3903    def get_password_rules_0_with_http_info(self, **kwargs):
3904        """
3905        Get membership account password rules
3906        
3907        This method makes a synchronous HTTP request by default. To make an
3908        asynchronous HTTP request, please define a `callback` function
3909        to be invoked when receiving the response.
3910        >>> def callback_function(response):
3911        >>>     pprint(response)
3912        >>>
3913        >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function)
3914
3915        :param callback function: The callback function
3916            for asynchronous request. (optional)
3917        :return: UserPasswordRules
3918                 If the method is called asynchronously,
3919                 returns the request thread.
3920        """
3921
3922        all_params = []
3923        all_params.append('callback')
3924        all_params.append('_return_http_data_only')
3925        all_params.append('_preload_content')
3926        all_params.append('_request_timeout')
3927
3928        params = locals()
3929        for key, val in iteritems(params['kwargs']):
3930            if key not in all_params:
3931                raise TypeError(
3932                    "Got an unexpected keyword argument '%s'"
3933                    " to method get_password_rules_0" % key
3934                )
3935            params[key] = val
3936        del params['kwargs']
3937
3938        collection_formats = {}
3939
3940        resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json')
3941        path_params = {}
3942
3943        query_params = {}
3944
3945        header_params = {}
3946
3947        form_params = []
3948        local_var_files = {}
3949
3950        body_params = None
3951        # HTTP header `Accept`
3952        header_params['Accept'] = self.api_client.\
3953            select_header_accept(['application/json'])
3954
3955        # Authentication setting
3956        auth_settings = []
3957
3958        return self.api_client.call_api(resource_path, 'GET',
3959                                        path_params,
3960                                        query_params,
3961                                        header_params,
3962                                        body=body_params,
3963                                        post_params=form_params,
3964                                        files=local_var_files,
3965                                        response_type='UserPasswordRules',
3966                                        auth_settings=auth_settings,
3967                                        callback=params.get('callback'),
3968                                        _return_http_data_only=params.get('_return_http_data_only'),
3969                                        _preload_content=params.get('_preload_content', True),
3970                                        _request_timeout=params.get('_request_timeout'),
3971                                        collection_formats=collection_formats)
3972
3973    def get_permission_profile(self, account_id, permission_profile_id, **kwargs):
3974        """
3975        Returns a permissions profile in the specified account.
3976        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
3977        This method makes a synchronous HTTP request by default. To make an
3978        asynchronous HTTP request, please define a `callback` function
3979        to be invoked when receiving the response.
3980        >>> def callback_function(response):
3981        >>>     pprint(response)
3982        >>>
3983        >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function)
3984
3985        :param callback function: The callback function
3986            for asynchronous request. (optional)
3987        :param str account_id: The external account number (int) or account ID Guid. (required)
3988        :param str permission_profile_id: (required)
3989        :param str include:
3990        :return: PermissionProfile
3991                 If the method is called asynchronously,
3992                 returns the request thread.
3993        """
3994        kwargs['_return_http_data_only'] = True
3995        if kwargs.get('callback'):
3996            return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3997        else:
3998            (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3999            return data
4000
4001    def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
4002        """
4003        Returns a permissions profile in the specified account.
4004        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
4005        This method makes a synchronous HTTP request by default. To make an
4006        asynchronous HTTP request, please define a `callback` function
4007        to be invoked when receiving the response.
4008        >>> def callback_function(response):
4009        >>>     pprint(response)
4010        >>>
4011        >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
4012
4013        :param callback function: The callback function
4014            for asynchronous request. (optional)
4015        :param str account_id: The external account number (int) or account ID Guid. (required)
4016        :param str permission_profile_id: (required)
4017        :param str include:
4018        :return: PermissionProfile
4019                 If the method is called asynchronously,
4020                 returns the request thread.
4021        """
4022
4023        all_params = ['account_id', 'permission_profile_id', 'include']
4024        all_params.append('callback')
4025        all_params.append('_return_http_data_only')
4026        all_params.append('_preload_content')
4027        all_params.append('_request_timeout')
4028
4029        params = locals()
4030        for key, val in iteritems(params['kwargs']):
4031            if key not in all_params:
4032                raise TypeError(
4033                    "Got an unexpected keyword argument '%s'"
4034                    " to method get_permission_profile" % key
4035                )
4036            params[key] = val
4037        del params['kwargs']
4038        # verify the required parameter 'account_id' is set
4039        if ('account_id' not in params) or (params['account_id'] is None):
4040            raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`")
4041        # verify the required parameter 'permission_profile_id' is set
4042        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
4043            raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`")
4044
4045
4046        collection_formats = {}
4047
4048        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
4049        path_params = {}
4050        if 'account_id' in params:
4051            path_params['accountId'] = params['account_id']
4052        if 'permission_profile_id' in params:
4053            path_params['permissionProfileId'] = params['permission_profile_id']
4054
4055        query_params = {}
4056        if 'include' in params:
4057            query_params['include'] = params['include']
4058
4059        header_params = {}
4060
4061        form_params = []
4062        local_var_files = {}
4063
4064        body_params = None
4065        # HTTP header `Accept`
4066        header_params['Accept'] = self.api_client.\
4067            select_header_accept(['application/json'])
4068
4069        # Authentication setting
4070        auth_settings = []
4071
4072        return self.api_client.call_api(resource_path, 'GET',
4073                                        path_params,
4074                                        query_params,
4075                                        header_params,
4076                                        body=body_params,
4077                                        post_params=form_params,
4078                                        files=local_var_files,
4079                                        response_type='PermissionProfile',
4080                                        auth_settings=auth_settings,
4081                                        callback=params.get('callback'),
4082                                        _return_http_data_only=params.get('_return_http_data_only'),
4083                                        _preload_content=params.get('_preload_content', True),
4084                                        _request_timeout=params.get('_request_timeout'),
4085                                        collection_formats=collection_formats)
4086
4087    def get_provisioning(self, **kwargs):
4088        """
4089        Retrieves the account provisioning information for the account.
4090        Retrieves the account provisioning information for the account.
4091        This method makes a synchronous HTTP request by default. To make an
4092        asynchronous HTTP request, please define a `callback` function
4093        to be invoked when receiving the response.
4094        >>> def callback_function(response):
4095        >>>     pprint(response)
4096        >>>
4097        >>> thread = api.get_provisioning(callback=callback_function)
4098
4099        :param callback function: The callback function
4100            for asynchronous request. (optional)
4101        :return: ProvisioningInformation
4102                 If the method is called asynchronously,
4103                 returns the request thread.
4104        """
4105        kwargs['_return_http_data_only'] = True
4106        if kwargs.get('callback'):
4107            return self.get_provisioning_with_http_info(**kwargs)
4108        else:
4109            (data) = self.get_provisioning_with_http_info(**kwargs)
4110            return data
4111
4112    def get_provisioning_with_http_info(self, **kwargs):
4113        """
4114        Retrieves the account provisioning information for the account.
4115        Retrieves the account provisioning information for the account.
4116        This method makes a synchronous HTTP request by default. To make an
4117        asynchronous HTTP request, please define a `callback` function
4118        to be invoked when receiving the response.
4119        >>> def callback_function(response):
4120        >>>     pprint(response)
4121        >>>
4122        >>> thread = api.get_provisioning_with_http_info(callback=callback_function)
4123
4124        :param callback function: The callback function
4125            for asynchronous request. (optional)
4126        :return: ProvisioningInformation
4127                 If the method is called asynchronously,
4128                 returns the request thread.
4129        """
4130
4131        all_params = []
4132        all_params.append('callback')
4133        all_params.append('_return_http_data_only')
4134        all_params.append('_preload_content')
4135        all_params.append('_request_timeout')
4136
4137        params = locals()
4138        for key, val in iteritems(params['kwargs']):
4139            if key not in all_params:
4140                raise TypeError(
4141                    "Got an unexpected keyword argument '%s'"
4142                    " to method get_provisioning" % key
4143                )
4144            params[key] = val
4145        del params['kwargs']
4146
4147        collection_formats = {}
4148
4149        resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json')
4150        path_params = {}
4151
4152        query_params = {}
4153
4154        header_params = {}
4155
4156        form_params = []
4157        local_var_files = {}
4158
4159        body_params = None
4160        # HTTP header `Accept`
4161        header_params['Accept'] = self.api_client.\
4162            select_header_accept(['application/json'])
4163
4164        # Authentication setting
4165        auth_settings = []
4166
4167        return self.api_client.call_api(resource_path, 'GET',
4168                                        path_params,
4169                                        query_params,
4170                                        header_params,
4171                                        body=body_params,
4172                                        post_params=form_params,
4173                                        files=local_var_files,
4174                                        response_type='ProvisioningInformation',
4175                                        auth_settings=auth_settings,
4176                                        callback=params.get('callback'),
4177                                        _return_http_data_only=params.get('_return_http_data_only'),
4178                                        _preload_content=params.get('_preload_content', True),
4179                                        _request_timeout=params.get('_request_timeout'),
4180                                        collection_formats=collection_formats)
4181
4182    def get_supported_languages(self, account_id, **kwargs):
4183        """
4184        Gets list of supported languages for recipient language setting.
4185        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4186        This method makes a synchronous HTTP request by default. To make an
4187        asynchronous HTTP request, please define a `callback` function
4188        to be invoked when receiving the response.
4189        >>> def callback_function(response):
4190        >>>     pprint(response)
4191        >>>
4192        >>> thread = api.get_supported_languages(account_id, callback=callback_function)
4193
4194        :param callback function: The callback function
4195            for asynchronous request. (optional)
4196        :param str account_id: The external account number (int) or account ID Guid. (required)
4197        :return: SupportedLanguages
4198                 If the method is called asynchronously,
4199                 returns the request thread.
4200        """
4201        kwargs['_return_http_data_only'] = True
4202        if kwargs.get('callback'):
4203            return self.get_supported_languages_with_http_info(account_id, **kwargs)
4204        else:
4205            (data) = self.get_supported_languages_with_http_info(account_id, **kwargs)
4206            return data
4207
4208    def get_supported_languages_with_http_info(self, account_id, **kwargs):
4209        """
4210        Gets list of supported languages for recipient language setting.
4211        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4212        This method makes a synchronous HTTP request by default. To make an
4213        asynchronous HTTP request, please define a `callback` function
4214        to be invoked when receiving the response.
4215        >>> def callback_function(response):
4216        >>>     pprint(response)
4217        >>>
4218        >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function)
4219
4220        :param callback function: The callback function
4221            for asynchronous request. (optional)
4222        :param str account_id: The external account number (int) or account ID Guid. (required)
4223        :return: SupportedLanguages
4224                 If the method is called asynchronously,
4225                 returns the request thread.
4226        """
4227
4228        all_params = ['account_id']
4229        all_params.append('callback')
4230        all_params.append('_return_http_data_only')
4231        all_params.append('_preload_content')
4232        all_params.append('_request_timeout')
4233
4234        params = locals()
4235        for key, val in iteritems(params['kwargs']):
4236            if key not in all_params:
4237                raise TypeError(
4238                    "Got an unexpected keyword argument '%s'"
4239                    " to method get_supported_languages" % key
4240                )
4241            params[key] = val
4242        del params['kwargs']
4243        # verify the required parameter 'account_id' is set
4244        if ('account_id' not in params) or (params['account_id'] is None):
4245            raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`")
4246
4247
4248        collection_formats = {}
4249
4250        resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json')
4251        path_params = {}
4252        if 'account_id' in params:
4253            path_params['accountId'] = params['account_id']
4254
4255        query_params = {}
4256
4257        header_params = {}
4258
4259        form_params = []
4260        local_var_files = {}
4261
4262        body_params = None
4263        # HTTP header `Accept`
4264        header_params['Accept'] = self.api_client.\
4265            select_header_accept(['application/json'])
4266
4267        # Authentication setting
4268        auth_settings = []
4269
4270        return self.api_client.call_api(resource_path, 'GET',
4271                                        path_params,
4272                                        query_params,
4273                                        header_params,
4274                                        body=body_params,
4275                                        post_params=form_params,
4276                                        files=local_var_files,
4277                                        response_type='SupportedLanguages',
4278                                        auth_settings=auth_settings,
4279                                        callback=params.get('callback'),
4280                                        _return_http_data_only=params.get('_return_http_data_only'),
4281                                        _preload_content=params.get('_preload_content', True),
4282                                        _request_timeout=params.get('_request_timeout'),
4283                                        collection_formats=collection_formats)
4284
4285    def get_watermark(self, account_id, **kwargs):
4286        """
4287        Get watermark information.
4288        
4289        This method makes a synchronous HTTP request by default. To make an
4290        asynchronous HTTP request, please define a `callback` function
4291        to be invoked when receiving the response.
4292        >>> def callback_function(response):
4293        >>>     pprint(response)
4294        >>>
4295        >>> thread = api.get_watermark(account_id, callback=callback_function)
4296
4297        :param callback function: The callback function
4298            for asynchronous request. (optional)
4299        :param str account_id: The external account number (int) or account ID Guid. (required)
4300        :return: Watermark
4301                 If the method is called asynchronously,
4302                 returns the request thread.
4303        """
4304        kwargs['_return_http_data_only'] = True
4305        if kwargs.get('callback'):
4306            return self.get_watermark_with_http_info(account_id, **kwargs)
4307        else:
4308            (data) = self.get_watermark_with_http_info(account_id, **kwargs)
4309            return data
4310
4311    def get_watermark_with_http_info(self, account_id, **kwargs):
4312        """
4313        Get watermark information.
4314        
4315        This method makes a synchronous HTTP request by default. To make an
4316        asynchronous HTTP request, please define a `callback` function
4317        to be invoked when receiving the response.
4318        >>> def callback_function(response):
4319        >>>     pprint(response)
4320        >>>
4321        >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function)
4322
4323        :param callback function: The callback function
4324            for asynchronous request. (optional)
4325        :param str account_id: The external account number (int) or account ID Guid. (required)
4326        :return: Watermark
4327                 If the method is called asynchronously,
4328                 returns the request thread.
4329        """
4330
4331        all_params = ['account_id']
4332        all_params.append('callback')
4333        all_params.append('_return_http_data_only')
4334        all_params.append('_preload_content')
4335        all_params.append('_request_timeout')
4336
4337        params = locals()
4338        for key, val in iteritems(params['kwargs']):
4339            if key not in all_params:
4340                raise TypeError(
4341                    "Got an unexpected keyword argument '%s'"
4342                    " to method get_watermark" % key
4343                )
4344            params[key] = val
4345        del params['kwargs']
4346        # verify the required parameter 'account_id' is set
4347        if ('account_id' not in params) or (params['account_id'] is None):
4348            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`")
4349
4350
4351        collection_formats = {}
4352
4353        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
4354        path_params = {}
4355        if 'account_id' in params:
4356            path_params['accountId'] = params['account_id']
4357
4358        query_params = {}
4359
4360        header_params = {}
4361
4362        form_params = []
4363        local_var_files = {}
4364
4365        body_params = None
4366        # HTTP header `Accept`
4367        header_params['Accept'] = self.api_client.\
4368            select_header_accept(['application/json'])
4369
4370        # Authentication setting
4371        auth_settings = []
4372
4373        return self.api_client.call_api(resource_path, 'GET',
4374                                        path_params,
4375                                        query_params,
4376                                        header_params,
4377                                        body=body_params,
4378                                        post_params=form_params,
4379                                        files=local_var_files,
4380                                        response_type='Watermark',
4381                                        auth_settings=auth_settings,
4382                                        callback=params.get('callback'),
4383                                        _return_http_data_only=params.get('_return_http_data_only'),
4384                                        _preload_content=params.get('_preload_content', True),
4385                                        _request_timeout=params.get('_request_timeout'),
4386                                        collection_formats=collection_formats)
4387
4388    def get_watermark_preview(self, account_id, **kwargs):
4389        """
4390        Get watermark preview.
4391        
4392        This method makes a synchronous HTTP request by default. To make an
4393        asynchronous HTTP request, please define a `callback` function
4394        to be invoked when receiving the response.
4395        >>> def callback_function(response):
4396        >>>     pprint(response)
4397        >>>
4398        >>> thread = api.get_watermark_preview(account_id, callback=callback_function)
4399
4400        :param callback function: The callback function
4401            for asynchronous request. (optional)
4402        :param str account_id: The external account number (int) or account ID Guid. (required)
4403        :param Watermark watermark:
4404        :return: Watermark
4405                 If the method is called asynchronously,
4406                 returns the request thread.
4407        """
4408        kwargs['_return_http_data_only'] = True
4409        if kwargs.get('callback'):
4410            return self.get_watermark_preview_with_http_info(account_id, **kwargs)
4411        else:
4412            (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs)
4413            return data
4414
4415    def get_watermark_preview_with_http_info(self, account_id, **kwargs):
4416        """
4417        Get watermark preview.
4418        
4419        This method makes a synchronous HTTP request by default. To make an
4420        asynchronous HTTP request, please define a `callback` function
4421        to be invoked when receiving the response.
4422        >>> def callback_function(response):
4423        >>>     pprint(response)
4424        >>>
4425        >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function)
4426
4427        :param callback function: The callback function
4428            for asynchronous request. (optional)
4429        :param str account_id: The external account number (int) or account ID Guid. (required)
4430        :param Watermark watermark:
4431        :return: Watermark
4432                 If the method is called asynchronously,
4433                 returns the request thread.
4434        """
4435
4436        all_params = ['account_id', 'watermark']
4437        all_params.append('callback')
4438        all_params.append('_return_http_data_only')
4439        all_params.append('_preload_content')
4440        all_params.append('_request_timeout')
4441
4442        params = locals()
4443        for key, val in iteritems(params['kwargs']):
4444            if key not in all_params:
4445                raise TypeError(
4446                    "Got an unexpected keyword argument '%s'"
4447                    " to method get_watermark_preview" % key
4448                )
4449            params[key] = val
4450        del params['kwargs']
4451        # verify the required parameter 'account_id' is set
4452        if ('account_id' not in params) or (params['account_id'] is None):
4453            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`")
4454
4455
4456        collection_formats = {}
4457
4458        resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json')
4459        path_params = {}
4460        if 'account_id' in params:
4461            path_params['accountId'] = params['account_id']
4462
4463        query_params = {}
4464
4465        header_params = {}
4466
4467        form_params = []
4468        local_var_files = {}
4469
4470        body_params = None
4471        if 'watermark' in params:
4472            body_params = params['watermark']
4473        # HTTP header `Accept`
4474        header_params['Accept'] = self.api_client.\
4475            select_header_accept(['application/json'])
4476
4477        # Authentication setting
4478        auth_settings = []
4479
4480        return self.api_client.call_api(resource_path, 'PUT',
4481                                        path_params,
4482                                        query_params,
4483                                        header_params,
4484                                        body=body_params,
4485                                        post_params=form_params,
4486                                        files=local_var_files,
4487                                        response_type='Watermark',
4488                                        auth_settings=auth_settings,
4489                                        callback=params.get('callback'),
4490                                        _return_http_data_only=params.get('_return_http_data_only'),
4491                                        _preload_content=params.get('_preload_content', True),
4492                                        _request_timeout=params.get('_request_timeout'),
4493                                        collection_formats=collection_formats)
4494
4495    def list_brands(self, account_id, **kwargs):
4496        """
4497        Gets a list of brand profiles.
4498        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4499        This method makes a synchronous HTTP request by default. To make an
4500        asynchronous HTTP request, please define a `callback` function
4501        to be invoked when receiving the response.
4502        >>> def callback_function(response):
4503        >>>     pprint(response)
4504        >>>
4505        >>> thread = api.list_brands(account_id, callback=callback_function)
4506
4507        :param callback function: The callback function
4508            for asynchronous request. (optional)
4509        :param str account_id: The external account number (int) or account ID Guid. (required)
4510        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4511        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4512        :return: BrandsResponse
4513                 If the method is called asynchronously,
4514                 returns the request thread.
4515        """
4516        kwargs['_return_http_data_only'] = True
4517        if kwargs.get('callback'):
4518            return self.list_brands_with_http_info(account_id, **kwargs)
4519        else:
4520            (data) = self.list_brands_with_http_info(account_id, **kwargs)
4521            return data
4522
4523    def list_brands_with_http_info(self, account_id, **kwargs):
4524        """
4525        Gets a list of brand profiles.
4526        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4527        This method makes a synchronous HTTP request by default. To make an
4528        asynchronous HTTP request, please define a `callback` function
4529        to be invoked when receiving the response.
4530        >>> def callback_function(response):
4531        >>>     pprint(response)
4532        >>>
4533        >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function)
4534
4535        :param callback function: The callback function
4536            for asynchronous request. (optional)
4537        :param str account_id: The external account number (int) or account ID Guid. (required)
4538        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4539        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4540        :return: BrandsResponse
4541                 If the method is called asynchronously,
4542                 returns the request thread.
4543        """
4544
4545        all_params = ['account_id', 'exclude_distributor_brand', 'include_logos']
4546        all_params.append('callback')
4547        all_params.append('_return_http_data_only')
4548        all_params.append('_preload_content')
4549        all_params.append('_request_timeout')
4550
4551        params = locals()
4552        for key, val in iteritems(params['kwargs']):
4553            if key not in all_params:
4554                raise TypeError(
4555                    "Got an unexpected keyword argument '%s'"
4556                    " to method list_brands" % key
4557                )
4558            params[key] = val
4559        del params['kwargs']
4560        # verify the required parameter 'account_id' is set
4561        if ('account_id' not in params) or (params['account_id'] is None):
4562            raise ValueError("Missing the required parameter `account_id` when calling `list_brands`")
4563
4564
4565        collection_formats = {}
4566
4567        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
4568        path_params = {}
4569        if 'account_id' in params:
4570            path_params['accountId'] = params['account_id']
4571
4572        query_params = {}
4573        if 'exclude_distributor_brand' in params:
4574            query_params['exclude_distributor_brand'] = params['exclude_distributor_brand']
4575        if 'include_logos' in params:
4576            query_params['include_logos'] = params['include_logos']
4577
4578        header_params = {}
4579
4580        form_params = []
4581        local_var_files = {}
4582
4583        body_params = None
4584        # HTTP header `Accept`
4585        header_params['Accept'] = self.api_client.\
4586            select_header_accept(['application/json'])
4587
4588        # Authentication setting
4589        auth_settings = []
4590
4591        return self.api_client.call_api(resource_path, 'GET',
4592                                        path_params,
4593                                        query_params,
4594                                        header_params,
4595                                        body=body_params,
4596                                        post_params=form_params,
4597                                        files=local_var_files,
4598                                        response_type='BrandsResponse',
4599                                        auth_settings=auth_settings,
4600                                        callback=params.get('callback'),
4601                                        _return_http_data_only=params.get('_return_http_data_only'),
4602                                        _preload_content=params.get('_preload_content', True),
4603                                        _request_timeout=params.get('_request_timeout'),
4604                                        collection_formats=collection_formats)
4605
4606    def list_custom_fields(self, account_id, **kwargs):
4607        """
4608        Gets a list of custom fields associated with the account.
4609        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4610        This method makes a synchronous HTTP request by default. To make an
4611        asynchronous HTTP request, please define a `callback` function
4612        to be invoked when receiving the response.
4613        >>> def callback_function(response):
4614        >>>     pprint(response)
4615        >>>
4616        >>> thread = api.list_custom_fields(account_id, callback=callback_function)
4617
4618        :param callback function: The callback function
4619            for asynchronous request. (optional)
4620        :param str account_id: The external account number (int) or account ID Guid. (required)
4621        :return: CustomFields
4622                 If the method is called asynchronously,
4623                 returns the request thread.
4624        """
4625        kwargs['_return_http_data_only'] = True
4626        if kwargs.get('callback'):
4627            return self.list_custom_fields_with_http_info(account_id, **kwargs)
4628        else:
4629            (data) = self.list_custom_fields_with_http_info(account_id, **kwargs)
4630            return data
4631
4632    def list_custom_fields_with_http_info(self, account_id, **kwargs):
4633        """
4634        Gets a list of custom fields associated with the account.
4635        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4636        This method makes a synchronous HTTP request by default. To make an
4637        asynchronous HTTP request, please define a `callback` function
4638        to be invoked when receiving the response.
4639        >>> def callback_function(response):
4640        >>>     pprint(response)
4641        >>>
4642        >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function)
4643
4644        :param callback function: The callback function
4645            for asynchronous request. (optional)
4646        :param str account_id: The external account number (int) or account ID Guid. (required)
4647        :return: CustomFields
4648                 If the method is called asynchronously,
4649                 returns the request thread.
4650        """
4651
4652        all_params = ['account_id']
4653        all_params.append('callback')
4654        all_params.append('_return_http_data_only')
4655        all_params.append('_preload_content')
4656        all_params.append('_request_timeout')
4657
4658        params = locals()
4659        for key, val in iteritems(params['kwargs']):
4660            if key not in all_params:
4661                raise TypeError(
4662                    "Got an unexpected keyword argument '%s'"
4663                    " to method list_custom_fields" % key
4664                )
4665            params[key] = val
4666        del params['kwargs']
4667        # verify the required parameter 'account_id' is set
4668        if ('account_id' not in params) or (params['account_id'] is None):
4669            raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`")
4670
4671
4672        collection_formats = {}
4673
4674        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
4675        path_params = {}
4676        if 'account_id' in params:
4677            path_params['accountId'] = params['account_id']
4678
4679        query_params = {}
4680
4681        header_params = {}
4682
4683        form_params = []
4684        local_var_files = {}
4685
4686        body_params = None
4687        # HTTP header `Accept`
4688        header_params['Accept'] = self.api_client.\
4689            select_header_accept(['application/json'])
4690
4691        # Authentication setting
4692        auth_settings = []
4693
4694        return self.api_client.call_api(resource_path, 'GET',
4695                                        path_params,
4696                                        query_params,
4697                                        header_params,
4698                                        body=body_params,
4699                                        post_params=form_params,
4700                                        files=local_var_files,
4701                                        response_type='CustomFields',
4702                                        auth_settings=auth_settings,
4703                                        callback=params.get('callback'),
4704                                        _return_http_data_only=params.get('_return_http_data_only'),
4705                                        _preload_content=params.get('_preload_content', True),
4706                                        _request_timeout=params.get('_request_timeout'),
4707                                        collection_formats=collection_formats)
4708
4709    def list_permissions(self, account_id, **kwargs):
4710        """
4711        Gets a list of permission profiles.
4712        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4713        This method makes a synchronous HTTP request by default. To make an
4714        asynchronous HTTP request, please define a `callback` function
4715        to be invoked when receiving the response.
4716        >>> def callback_function(response):
4717        >>>     pprint(response)
4718        >>>
4719        >>> thread = api.list_permissions(account_id, callback=callback_function)
4720
4721        :param callback function: The callback function
4722            for asynchronous request. (optional)
4723        :param str account_id: The external account number (int) or account ID Guid. (required)
4724        :param str include:
4725        :return: PermissionProfileInformation
4726                 If the method is called asynchronously,
4727                 returns the request thread.
4728        """
4729        kwargs['_return_http_data_only'] = True
4730        if kwargs.get('callback'):
4731            return self.list_permissions_with_http_info(account_id, **kwargs)
4732        else:
4733            (data) = self.list_permissions_with_http_info(account_id, **kwargs)
4734            return data
4735
4736    def list_permissions_with_http_info(self, account_id, **kwargs):
4737        """
4738        Gets a list of permission profiles.
4739        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4740        This method makes a synchronous HTTP request by default. To make an
4741        asynchronous HTTP request, please define a `callback` function
4742        to be invoked when receiving the response.
4743        >>> def callback_function(response):
4744        >>>     pprint(response)
4745        >>>
4746        >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
4747
4748        :param callback function: The callback function
4749            for asynchronous request. (optional)
4750        :param str account_id: The external account number (int) or account ID Guid. (required)
4751        :param str include:
4752        :return: PermissionProfileInformation
4753                 If the method is called asynchronously,
4754                 returns the request thread.
4755        """
4756
4757        all_params = ['account_id', 'include']
4758        all_params.append('callback')
4759        all_params.append('_return_http_data_only')
4760        all_params.append('_preload_content')
4761        all_params.append('_request_timeout')
4762
4763        params = locals()
4764        for key, val in iteritems(params['kwargs']):
4765            if key not in all_params:
4766                raise TypeError(
4767                    "Got an unexpected keyword argument '%s'"
4768                    " to method list_permissions" % key
4769                )
4770            params[key] = val
4771        del params['kwargs']
4772        # verify the required parameter 'account_id' is set
4773        if ('account_id' not in params) or (params['account_id'] is None):
4774            raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`")
4775
4776
4777        collection_formats = {}
4778
4779        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
4780        path_params = {}
4781        if 'account_id' in params:
4782            path_params['accountId'] = params['account_id']
4783
4784        query_params = {}
4785        if 'include' in params:
4786            query_params['include'] = params['include']
4787
4788        header_params = {}
4789
4790        form_params = []
4791        local_var_files = {}
4792
4793        body_params = None
4794        # HTTP header `Accept`
4795        header_params['Accept'] = self.api_client.\
4796            select_header_accept(['application/json'])
4797
4798        # Authentication setting
4799        auth_settings = []
4800
4801        return self.api_client.call_api(resource_path, 'GET',
4802                                        path_params,
4803                                        query_params,
4804                                        header_params,
4805                                        body=body_params,
4806                                        post_params=form_params,
4807                                        files=local_var_files,
4808                                        response_type='PermissionProfileInformation',
4809                                        auth_settings=auth_settings,
4810                                        callback=params.get('callback'),
4811                                        _return_http_data_only=params.get('_return_http_data_only'),
4812                                        _preload_content=params.get('_preload_content', True),
4813                                        _request_timeout=params.get('_request_timeout'),
4814                                        collection_formats=collection_formats)
4815
4816    def list_recipient_names_by_email(self, account_id, **kwargs):
4817        """
4818        Gets recipient names associated with an email address.
4819        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4820        This method makes a synchronous HTTP request by default. To make an
4821        asynchronous HTTP request, please define a `callback` function
4822        to be invoked when receiving the response.
4823        >>> def callback_function(response):
4824        >>>     pprint(response)
4825        >>>
4826        >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
4827
4828        :param callback function: The callback function
4829            for asynchronous request. (optional)
4830        :param str account_id: The external account number (int) or account ID Guid. (required)
4831        :param str email: The email address for the user
4832        :return: RecipientNamesResponse
4833                 If the method is called asynchronously,
4834                 returns the request thread.
4835        """
4836        kwargs['_return_http_data_only'] = True
4837        if kwargs.get('callback'):
4838            return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4839        else:
4840            (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4841            return data
4842
4843    def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs):
4844        """
4845        Gets recipient names associated with an email address.
4846        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4847        This method makes a synchronous HTTP request by default. To make an
4848        asynchronous HTTP request, please define a `callback` function
4849        to be invoked when receiving the response.
4850        >>> def callback_function(response):
4851        >>>     pprint(response)
4852        >>>
4853        >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
4854
4855        :param callback function: The callback function
4856            for asynchronous request. (optional)
4857        :param str account_id: The external account number (int) or account ID Guid. (required)
4858        :param str email: The email address for the user
4859        :return: RecipientNamesResponse
4860                 If the method is called asynchronously,
4861                 returns the request thread.
4862        """
4863
4864        all_params = ['account_id', 'email']
4865        all_params.append('callback')
4866        all_params.append('_return_http_data_only')
4867        all_params.append('_preload_content')
4868        all_params.append('_request_timeout')
4869
4870        params = locals()
4871        for key, val in iteritems(params['kwargs']):
4872            if key not in all_params:
4873                raise TypeError(
4874                    "Got an unexpected keyword argument '%s'"
4875                    " to method list_recipient_names_by_email" % key
4876                )
4877            params[key] = val
4878        del params['kwargs']
4879        # verify the required parameter 'account_id' is set
4880        if ('account_id' not in params) or (params['account_id'] is None):
4881            raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`")
4882
4883
4884        collection_formats = {}
4885
4886        resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json')
4887        path_params = {}
4888        if 'account_id' in params:
4889            path_params['accountId'] = params['account_id']
4890
4891        query_params = {}
4892        if 'email' in params:
4893            query_params['email'] = params['email']
4894
4895        header_params = {}
4896
4897        form_params = []
4898        local_var_files = {}
4899
4900        body_params = None
4901        # HTTP header `Accept`
4902        header_params['Accept'] = self.api_client.\
4903            select_header_accept(['application/json'])
4904
4905        # Authentication setting
4906        auth_settings = []
4907
4908        return self.api_client.call_api(resource_path, 'GET',
4909                                        path_params,
4910                                        query_params,
4911                                        header_params,
4912                                        body=body_params,
4913                                        post_params=form_params,
4914                                        files=local_var_files,
4915                                        response_type='RecipientNamesResponse',
4916                                        auth_settings=auth_settings,
4917                                        callback=params.get('callback'),
4918                                        _return_http_data_only=params.get('_return_http_data_only'),
4919                                        _preload_content=params.get('_preload_content', True),
4920                                        _request_timeout=params.get('_request_timeout'),
4921                                        collection_formats=collection_formats)
4922
4923    def list_settings(self, account_id, **kwargs):
4924        """
4925        Gets account settings information.
4926        Retrieves the account settings information for the specified account.
4927        This method makes a synchronous HTTP request by default. To make an
4928        asynchronous HTTP request, please define a `callback` function
4929        to be invoked when receiving the response.
4930        >>> def callback_function(response):
4931        >>>     pprint(response)
4932        >>>
4933        >>> thread = api.list_settings(account_id, callback=callback_function)
4934
4935        :param callback function: The callback function
4936            for asynchronous request. (optional)
4937        :param str account_id: The external account number (int) or account ID Guid. (required)
4938        :return: AccountSettingsInformation
4939                 If the method is called asynchronously,
4940                 returns the request thread.
4941        """
4942        kwargs['_return_http_data_only'] = True
4943        if kwargs.get('callback'):
4944            return self.list_settings_with_http_info(account_id, **kwargs)
4945        else:
4946            (data) = self.list_settings_with_http_info(account_id, **kwargs)
4947            return data
4948
4949    def list_settings_with_http_info(self, account_id, **kwargs):
4950        """
4951        Gets account settings information.
4952        Retrieves the account settings information for the specified account.
4953        This method makes a synchronous HTTP request by default. To make an
4954        asynchronous HTTP request, please define a `callback` function
4955        to be invoked when receiving the response.
4956        >>> def callback_function(response):
4957        >>>     pprint(response)
4958        >>>
4959        >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function)
4960
4961        :param callback function: The callback function
4962            for asynchronous request. (optional)
4963        :param str account_id: The external account number (int) or account ID Guid. (required)
4964        :return: AccountSettingsInformation
4965                 If the method is called asynchronously,
4966                 returns the request thread.
4967        """
4968
4969        all_params = ['account_id']
4970        all_params.append('callback')
4971        all_params.append('_return_http_data_only')
4972        all_params.append('_preload_content')
4973        all_params.append('_request_timeout')
4974
4975        params = locals()
4976        for key, val in iteritems(params['kwargs']):
4977            if key not in all_params:
4978                raise TypeError(
4979                    "Got an unexpected keyword argument '%s'"
4980                    " to method list_settings" % key
4981                )
4982            params[key] = val
4983        del params['kwargs']
4984        # verify the required parameter 'account_id' is set
4985        if ('account_id' not in params) or (params['account_id'] is None):
4986            raise ValueError("Missing the required parameter `account_id` when calling `list_settings`")
4987
4988
4989        collection_formats = {}
4990
4991        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
4992        path_params = {}
4993        if 'account_id' in params:
4994            path_params['accountId'] = params['account_id']
4995
4996        query_params = {}
4997
4998        header_params = {}
4999
5000        form_params = []
5001        local_var_files = {}
5002
5003        body_params = None
5004        # HTTP header `Accept`
5005        header_params['Accept'] = self.api_client.\
5006            select_header_accept(['application/json'])
5007
5008        # Authentication setting
5009        auth_settings = []
5010
5011        return self.api_client.call_api(resource_path, 'GET',
5012                                        path_params,
5013                                        query_params,
5014                                        header_params,
5015                                        body=body_params,
5016                                        post_params=form_params,
5017                                        files=local_var_files,
5018                                        response_type='AccountSettingsInformation',
5019                                        auth_settings=auth_settings,
5020                                        callback=params.get('callback'),
5021                                        _return_http_data_only=params.get('_return_http_data_only'),
5022                                        _preload_content=params.get('_preload_content', True),
5023                                        _request_timeout=params.get('_request_timeout'),
5024                                        collection_formats=collection_formats)
5025
5026    def list_shared_access(self, account_id, **kwargs):
5027        """
5028        Reserved: Gets the shared item status for one or more users.
5029        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5030        This method makes a synchronous HTTP request by default. To make an
5031        asynchronous HTTP request, please define a `callback` function
5032        to be invoked when receiving the response.
5033        >>> def callback_function(response):
5034        >>>     pprint(response)
5035        >>>
5036        >>> thread = api.list_shared_access(account_id, callback=callback_function)
5037
5038        :param callback function: The callback function
5039            for asynchronous request. (optional)
5040        :param str account_id: The external account number (int) or account ID Guid. (required)
5041        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5042        :param str envelopes_not_shared_user_status:
5043        :param str folder_ids:
5044        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5045        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5046        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5047        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5048        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5049        :return: AccountSharedAccess
5050                 If the method is called asynchronously,
5051                 returns the request thread.
5052        """
5053        kwargs['_return_http_data_only'] = True
5054        if kwargs.get('callback'):
5055            return self.list_shared_access_with_http_info(account_id, **kwargs)
5056        else:
5057            (data) = self.list_shared_access_with_http_info(account_id, **kwargs)
5058            return data
5059
5060    def list_shared_access_with_http_info(self, account_id, **kwargs):
5061        """
5062        Reserved: Gets the shared item status for one or more users.
5063        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5064        This method makes a synchronous HTTP request by default. To make an
5065        asynchronous HTTP request, please define a `callback` function
5066        to be invoked when receiving the response.
5067        >>> def callback_function(response):
5068        >>>     pprint(response)
5069        >>>
5070        >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function)
5071
5072        :param callback function: The callback function
5073            for asynchronous request. (optional)
5074        :param str account_id: The external account number (int) or account ID Guid. (required)
5075        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5076        :param str envelopes_not_shared_user_status:
5077        :param str folder_ids:
5078        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5079        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5080        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5081        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5082        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5083        :return: AccountSharedAccess
5084                 If the method is called asynchronously,
5085                 returns the request thread.
5086        """
5087
5088        all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids']
5089        all_params.append('callback')
5090        all_params.append('_return_http_data_only')
5091        all_params.append('_preload_content')
5092        all_params.append('_request_timeout')
5093
5094        params = locals()
5095        for key, val in iteritems(params['kwargs']):
5096            if key not in all_params:
5097                raise TypeError(
5098                    "Got an unexpected keyword argument '%s'"
5099                    " to method list_shared_access" % key
5100                )
5101            params[key] = val
5102        del params['kwargs']
5103        # verify the required parameter 'account_id' is set
5104        if ('account_id' not in params) or (params['account_id'] is None):
5105            raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`")
5106
5107
5108        collection_formats = {}
5109
5110        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
5111        path_params = {}
5112        if 'account_id' in params:
5113            path_params['accountId'] = params['account_id']
5114
5115        query_params = {}
5116        if 'count' in params:
5117            query_params['count'] = params['count']
5118        if 'envelopes_not_shared_user_status' in params:
5119            query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status']
5120        if 'folder_ids' in params:
5121            query_params['folder_ids'] = params['folder_ids']
5122        if 'item_type' in params:
5123            query_params['item_type'] = params['item_type']
5124        if 'search_text' in params:
5125            query_params['search_text'] = params['search_text']
5126        if 'shared' in params:
5127            query_params['shared'] = params['shared']
5128        if 'start_position' in params:
5129            query_params['start_position'] = params['start_position']
5130        if 'user_ids' in params:
5131            query_params['user_ids'] = params['user_ids']
5132
5133        header_params = {}
5134
5135        form_params = []
5136        local_var_files = {}
5137
5138        body_params = None
5139        # HTTP header `Accept`
5140        header_params['Accept'] = self.api_client.\
5141            select_header_accept(['application/json'])
5142
5143        # Authentication setting
5144        auth_settings = []
5145
5146        return self.api_client.call_api(resource_path, 'GET',
5147                                        path_params,
5148                                        query_params,
5149                                        header_params,
5150                                        body=body_params,
5151                                        post_params=form_params,
5152                                        files=local_var_files,
5153                                        response_type='AccountSharedAccess',
5154                                        auth_settings=auth_settings,
5155                                        callback=params.get('callback'),
5156                                        _return_http_data_only=params.get('_return_http_data_only'),
5157                                        _preload_content=params.get('_preload_content', True),
5158                                        _request_timeout=params.get('_request_timeout'),
5159                                        collection_formats=collection_formats)
5160
5161    def list_signature_providers(self, account_id, **kwargs):
5162        """
5163        Returns Account available signature providers for specified account.
5164        Returns a list of signature providers that the specified account can use.
5165        This method makes a synchronous HTTP request by default. To make an
5166        asynchronous HTTP request, please define a `callback` function
5167        to be invoked when receiving the response.
5168        >>> def callback_function(response):
5169        >>>     pprint(response)
5170        >>>
5171        >>> thread = api.list_signature_providers(account_id, callback=callback_function)
5172
5173        :param callback function: The callback function
5174            for asynchronous request. (optional)
5175        :param str account_id: The external account number (int) or account ID Guid. (required)
5176        :return: AccountSignatureProviders
5177                 If the method is called asynchronously,
5178                 returns the request thread.
5179        """
5180        kwargs['_return_http_data_only'] = True
5181        if kwargs.get('callback'):
5182            return self.list_signature_providers_with_http_info(account_id, **kwargs)
5183        else:
5184            (data) = self.list_signature_providers_with_http_info(account_id, **kwargs)
5185            return data
5186
5187    def list_signature_providers_with_http_info(self, account_id, **kwargs):
5188        """
5189        Returns Account available signature providers for specified account.
5190        Returns a list of signature providers that the specified account can use.
5191        This method makes a synchronous HTTP request by default. To make an
5192        asynchronous HTTP request, please define a `callback` function
5193        to be invoked when receiving the response.
5194        >>> def callback_function(response):
5195        >>>     pprint(response)
5196        >>>
5197        >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function)
5198
5199        :param callback function: The callback function
5200            for asynchronous request. (optional)
5201        :param str account_id: The external account number (int) or account ID Guid. (required)
5202        :return: AccountSignatureProviders
5203                 If the method is called asynchronously,
5204                 returns the request thread.
5205        """
5206
5207        all_params = ['account_id']
5208        all_params.append('callback')
5209        all_params.append('_return_http_data_only')
5210        all_params.append('_preload_content')
5211        all_params.append('_request_timeout')
5212
5213        params = locals()
5214        for key, val in iteritems(params['kwargs']):
5215            if key not in all_params:
5216                raise TypeError(
5217                    "Got an unexpected keyword argument '%s'"
5218                    " to method list_signature_providers" % key
5219                )
5220            params[key] = val
5221        del params['kwargs']
5222        # verify the required parameter 'account_id' is set
5223        if ('account_id' not in params) or (params['account_id'] is None):
5224            raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`")
5225
5226
5227        collection_formats = {}
5228
5229        resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json')
5230        path_params = {}
5231        if 'account_id' in params:
5232            path_params['accountId'] = params['account_id']
5233
5234        query_params = {}
5235
5236        header_params = {}
5237
5238        form_params = []
5239        local_var_files = {}
5240
5241        body_params = None
5242        # HTTP header `Accept`
5243        header_params['Accept'] = self.api_client.\
5244            select_header_accept(['application/json'])
5245
5246        # Authentication setting
5247        auth_settings = []
5248
5249        return self.api_client.call_api(resource_path, 'GET',
5250                                        path_params,
5251                                        query_params,
5252                                        header_params,
5253                                        body=body_params,
5254                                        post_params=form_params,
5255                                        files=local_var_files,
5256                                        response_type='AccountSignatureProviders',
5257                                        auth_settings=auth_settings,
5258                                        callback=params.get('callback'),
5259                                        _return_http_data_only=params.get('_return_http_data_only'),
5260                                        _preload_content=params.get('_preload_content', True),
5261                                        _request_timeout=params.get('_request_timeout'),
5262                                        collection_formats=collection_formats)
5263
5264    def list_unsupported_file_types(self, account_id, **kwargs):
5265        """
5266        Gets a list of unsupported file types.
5267        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5268        This method makes a synchronous HTTP request by default. To make an
5269        asynchronous HTTP request, please define a `callback` function
5270        to be invoked when receiving the response.
5271        >>> def callback_function(response):
5272        >>>     pprint(response)
5273        >>>
5274        >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function)
5275
5276        :param callback function: The callback function
5277            for asynchronous request. (optional)
5278        :param str account_id: The external account number (int) or account ID Guid. (required)
5279        :return: FileTypeList
5280                 If the method is called asynchronously,
5281                 returns the request thread.
5282        """
5283        kwargs['_return_http_data_only'] = True
5284        if kwargs.get('callback'):
5285            return self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5286        else:
5287            (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5288            return data
5289
5290    def list_unsupported_file_types_with_http_info(self, account_id, **kwargs):
5291        """
5292        Gets a list of unsupported file types.
5293        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5294        This method makes a synchronous HTTP request by default. To make an
5295        asynchronous HTTP request, please define a `callback` function
5296        to be invoked when receiving the response.
5297        >>> def callback_function(response):
5298        >>>     pprint(response)
5299        >>>
5300        >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function)
5301
5302        :param callback function: The callback function
5303            for asynchronous request. (optional)
5304        :param str account_id: The external account number (int) or account ID Guid. (required)
5305        :return: FileTypeList
5306                 If the method is called asynchronously,
5307                 returns the request thread.
5308        """
5309
5310        all_params = ['account_id']
5311        all_params.append('callback')
5312        all_params.append('_return_http_data_only')
5313        all_params.append('_preload_content')
5314        all_params.append('_request_timeout')
5315
5316        params = locals()
5317        for key, val in iteritems(params['kwargs']):
5318            if key not in all_params:
5319                raise TypeError(
5320                    "Got an unexpected keyword argument '%s'"
5321                    " to method list_unsupported_file_types" % key
5322                )
5323            params[key] = val
5324        del params['kwargs']
5325        # verify the required parameter 'account_id' is set
5326        if ('account_id' not in params) or (params['account_id'] is None):
5327            raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`")
5328
5329
5330        collection_formats = {}
5331
5332        resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json')
5333        path_params = {}
5334        if 'account_id' in params:
5335            path_params['accountId'] = params['account_id']
5336
5337        query_params = {}
5338
5339        header_params = {}
5340
5341        form_params = []
5342        local_var_files = {}
5343
5344        body_params = None
5345        # HTTP header `Accept`
5346        header_params['Accept'] = self.api_client.\
5347            select_header_accept(['application/json'])
5348
5349        # Authentication setting
5350        auth_settings = []
5351
5352        return self.api_client.call_api(resource_path, 'GET',
5353                                        path_params,
5354                                        query_params,
5355                                        header_params,
5356                                        body=body_params,
5357                                        post_params=form_params,
5358                                        files=local_var_files,
5359                                        response_type='FileTypeList',
5360                                        auth_settings=auth_settings,
5361                                        callback=params.get('callback'),
5362                                        _return_http_data_only=params.get('_return_http_data_only'),
5363                                        _preload_content=params.get('_preload_content', True),
5364                                        _request_timeout=params.get('_request_timeout'),
5365                                        collection_formats=collection_formats)
5366
5367    def un_favorite_template(self, account_id, **kwargs):
5368        """
5369        Unfavorite a template
5370        
5371        This method makes a synchronous HTTP request by default. To make an
5372        asynchronous HTTP request, please define a `callback` function
5373        to be invoked when receiving the response.
5374        >>> def callback_function(response):
5375        >>>     pprint(response)
5376        >>>
5377        >>> thread = api.un_favorite_template(account_id, callback=callback_function)
5378
5379        :param callback function: The callback function
5380            for asynchronous request. (optional)
5381        :param str account_id: The external account number (int) or account ID Guid. (required)
5382        :param FavoriteTemplatesInfo favorite_templates_info:
5383        :return: FavoriteTemplatesInfo
5384                 If the method is called asynchronously,
5385                 returns the request thread.
5386        """
5387        kwargs['_return_http_data_only'] = True
5388        if kwargs.get('callback'):
5389            return self.un_favorite_template_with_http_info(account_id, **kwargs)
5390        else:
5391            (data) = self.un_favorite_template_with_http_info(account_id, **kwargs)
5392            return data
5393
5394    def un_favorite_template_with_http_info(self, account_id, **kwargs):
5395        """
5396        Unfavorite a template
5397        
5398        This method makes a synchronous HTTP request by default. To make an
5399        asynchronous HTTP request, please define a `callback` function
5400        to be invoked when receiving the response.
5401        >>> def callback_function(response):
5402        >>>     pprint(response)
5403        >>>
5404        >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function)
5405
5406        :param callback function: The callback function
5407            for asynchronous request. (optional)
5408        :param str account_id: The external account number (int) or account ID Guid. (required)
5409        :param FavoriteTemplatesInfo favorite_templates_info:
5410        :return: FavoriteTemplatesInfo
5411                 If the method is called asynchronously,
5412                 returns the request thread.
5413        """
5414
5415        all_params = ['account_id', 'favorite_templates_info']
5416        all_params.append('callback')
5417        all_params.append('_return_http_data_only')
5418        all_params.append('_preload_content')
5419        all_params.append('_request_timeout')
5420
5421        params = locals()
5422        for key, val in iteritems(params['kwargs']):
5423            if key not in all_params:
5424                raise TypeError(
5425                    "Got an unexpected keyword argument '%s'"
5426                    " to method un_favorite_template" % key
5427                )
5428            params[key] = val
5429        del params['kwargs']
5430        # verify the required parameter 'account_id' is set
5431        if ('account_id' not in params) or (params['account_id'] is None):
5432            raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`")
5433
5434
5435        collection_formats = {}
5436
5437        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
5438        path_params = {}
5439        if 'account_id' in params:
5440            path_params['accountId'] = params['account_id']
5441
5442        query_params = {}
5443
5444        header_params = {}
5445
5446        form_params = []
5447        local_var_files = {}
5448
5449        body_params = None
5450        if 'favorite_templates_info' in params:
5451            body_params = params['favorite_templates_info']
5452        # HTTP header `Accept`
5453        header_params['Accept'] = self.api_client.\
5454            select_header_accept(['application/json'])
5455
5456        # Authentication setting
5457        auth_settings = []
5458
5459        return self.api_client.call_api(resource_path, 'DELETE',
5460                                        path_params,
5461                                        query_params,
5462                                        header_params,
5463                                        body=body_params,
5464                                        post_params=form_params,
5465                                        files=local_var_files,
5466                                        response_type='FavoriteTemplatesInfo',
5467                                        auth_settings=auth_settings,
5468                                        callback=params.get('callback'),
5469                                        _return_http_data_only=params.get('_return_http_data_only'),
5470                                        _preload_content=params.get('_preload_content', True),
5471                                        _request_timeout=params.get('_request_timeout'),
5472                                        collection_formats=collection_formats)
5473
5474    def update_account_signature(self, account_id, **kwargs):
5475        """
5476        Updates a account signature.
5477        
5478        This method makes a synchronous HTTP request by default. To make an
5479        asynchronous HTTP request, please define a `callback` function
5480        to be invoked when receiving the response.
5481        >>> def callback_function(response):
5482        >>>     pprint(response)
5483        >>>
5484        >>> thread = api.update_account_signature(account_id, callback=callback_function)
5485
5486        :param callback function: The callback function
5487            for asynchronous request. (optional)
5488        :param str account_id: The external account number (int) or account ID Guid. (required)
5489        :param AccountSignaturesInformation account_signatures_information:
5490        :return: AccountSignaturesInformation
5491                 If the method is called asynchronously,
5492                 returns the request thread.
5493        """
5494        kwargs['_return_http_data_only'] = True
5495        if kwargs.get('callback'):
5496            return self.update_account_signature_with_http_info(account_id, **kwargs)
5497        else:
5498            (data) = self.update_account_signature_with_http_info(account_id, **kwargs)
5499            return data
5500
5501    def update_account_signature_with_http_info(self, account_id, **kwargs):
5502        """
5503        Updates a account signature.
5504        
5505        This method makes a synchronous HTTP request by default. To make an
5506        asynchronous HTTP request, please define a `callback` function
5507        to be invoked when receiving the response.
5508        >>> def callback_function(response):
5509        >>>     pprint(response)
5510        >>>
5511        >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function)
5512
5513        :param callback function: The callback function
5514            for asynchronous request. (optional)
5515        :param str account_id: The external account number (int) or account ID Guid. (required)
5516        :param AccountSignaturesInformation account_signatures_information:
5517        :return: AccountSignaturesInformation
5518                 If the method is called asynchronously,
5519                 returns the request thread.
5520        """
5521
5522        all_params = ['account_id', 'account_signatures_information']
5523        all_params.append('callback')
5524        all_params.append('_return_http_data_only')
5525        all_params.append('_preload_content')
5526        all_params.append('_request_timeout')
5527
5528        params = locals()
5529        for key, val in iteritems(params['kwargs']):
5530            if key not in all_params:
5531                raise TypeError(
5532                    "Got an unexpected keyword argument '%s'"
5533                    " to method update_account_signature" % key
5534                )
5535            params[key] = val
5536        del params['kwargs']
5537        # verify the required parameter 'account_id' is set
5538        if ('account_id' not in params) or (params['account_id'] is None):
5539            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`")
5540
5541
5542        collection_formats = {}
5543
5544        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
5545        path_params = {}
5546        if 'account_id' in params:
5547            path_params['accountId'] = params['account_id']
5548
5549        query_params = {}
5550
5551        header_params = {}
5552
5553        form_params = []
5554        local_var_files = {}
5555
5556        body_params = None
5557        if 'account_signatures_information' in params:
5558            body_params = params['account_signatures_information']
5559        # HTTP header `Accept`
5560        header_params['Accept'] = self.api_client.\
5561            select_header_accept(['application/json'])
5562
5563        # Authentication setting
5564        auth_settings = []
5565
5566        return self.api_client.call_api(resource_path, 'PUT',
5567                                        path_params,
5568                                        query_params,
5569                                        header_params,
5570                                        body=body_params,
5571                                        post_params=form_params,
5572                                        files=local_var_files,
5573                                        response_type='AccountSignaturesInformation',
5574                                        auth_settings=auth_settings,
5575                                        callback=params.get('callback'),
5576                                        _return_http_data_only=params.get('_return_http_data_only'),
5577                                        _preload_content=params.get('_preload_content', True),
5578                                        _request_timeout=params.get('_request_timeout'),
5579                                        collection_formats=collection_formats)
5580
5581    def update_account_signature_by_id(self, account_id, signature_id, **kwargs):
5582        """
5583        Updates a account signature.
5584        
5585        This method makes a synchronous HTTP request by default. To make an
5586        asynchronous HTTP request, please define a `callback` function
5587        to be invoked when receiving the response.
5588        >>> def callback_function(response):
5589        >>>     pprint(response)
5590        >>>
5591        >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function)
5592
5593        :param callback function: The callback function
5594            for asynchronous request. (optional)
5595        :param str account_id: The external account number (int) or account ID Guid. (required)
5596        :param str signature_id: The ID of the signature being accessed. (required)
5597        :param str close_existing_signature:
5598        :param AccountSignatureDefinition account_signature_definition:
5599        :return: AccountSignature
5600                 If the method is called asynchronously,
5601                 returns the request thread.
5602        """
5603        kwargs['_return_http_data_only'] = True
5604        if kwargs.get('callback'):
5605            return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5606        else:
5607            (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5608            return data
5609
5610    def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs):
5611        """
5612        Updates a account signature.
5613        
5614        This method makes a synchronous HTTP request by default. To make an
5615        asynchronous HTTP request, please define a `callback` function
5616        to be invoked when receiving the response.
5617        >>> def callback_function(response):
5618        >>>     pprint(response)
5619        >>>
5620        >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
5621
5622        :param callback function: The callback function
5623            for asynchronous request. (optional)
5624        :param str account_id: The external account number (int) or account ID Guid. (required)
5625        :param str signature_id: The ID of the signature being accessed. (required)
5626        :param str close_existing_signature:
5627        :param AccountSignatureDefinition account_signature_definition:
5628        :return: AccountSignature
5629                 If the method is called asynchronously,
5630                 returns the request thread.
5631        """
5632
5633        all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition']
5634        all_params.append('callback')
5635        all_params.append('_return_http_data_only')
5636        all_params.append('_preload_content')
5637        all_params.append('_request_timeout')
5638
5639        params = locals()
5640        for key, val in iteritems(params['kwargs']):
5641            if key not in all_params:
5642                raise TypeError(
5643                    "Got an unexpected keyword argument '%s'"
5644                    " to method update_account_signature_by_id" % key
5645                )
5646            params[key] = val
5647        del params['kwargs']
5648        # verify the required parameter 'account_id' is set
5649        if ('account_id' not in params) or (params['account_id'] is None):
5650            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`")
5651        # verify the required parameter 'signature_id' is set
5652        if ('signature_id' not in params) or (params['signature_id'] is None):
5653            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`")
5654
5655
5656        collection_formats = {}
5657
5658        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
5659        path_params = {}
5660        if 'account_id' in params:
5661            path_params['accountId'] = params['account_id']
5662        if 'signature_id' in params:
5663            path_params['signatureId'] = params['signature_id']
5664
5665        query_params = {}
5666        if 'close_existing_signature' in params:
5667            query_params['close_existing_signature'] = params['close_existing_signature']
5668
5669        header_params = {}
5670
5671        form_params = []
5672        local_var_files = {}
5673
5674        body_params = None
5675        if 'account_signature_definition' in params:
5676            body_params = params['account_signature_definition']
5677        # HTTP header `Accept`
5678        header_params['Accept'] = self.api_client.\
5679            select_header_accept(['application/json'])
5680
5681        # Authentication setting
5682        auth_settings = []
5683
5684        return self.api_client.call_api(resource_path, 'PUT',
5685                                        path_params,
5686                                        query_params,
5687                                        header_params,
5688                                        body=body_params,
5689                                        post_params=form_params,
5690                                        files=local_var_files,
5691                                        response_type='AccountSignature',
5692                                        auth_settings=auth_settings,
5693                                        callback=params.get('callback'),
5694                                        _return_http_data_only=params.get('_return_http_data_only'),
5695                                        _preload_content=params.get('_preload_content', True),
5696                                        _request_timeout=params.get('_request_timeout'),
5697                                        collection_formats=collection_formats)
5698
5699    def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
5700        """
5701        Sets a signature, initials, or stamps image.
5702        
5703        This method makes a synchronous HTTP request by default. To make an
5704        asynchronous HTTP request, please define a `callback` function
5705        to be invoked when receiving the response.
5706        >>> def callback_function(response):
5707        >>>     pprint(response)
5708        >>>
5709        >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
5710
5711        :param callback function: The callback function
5712            for asynchronous request. (optional)
5713        :param str account_id: The external account number (int) or account ID Guid. (required)
5714        :param str image_type: One of **signature_image** or **initials_image**. (required)
5715        :param str signature_id: The ID of the signature being accessed. (required)
5716        :param str transparent_png:
5717        :return: AccountSignature
5718                 If the method is called asynchronously,
5719                 returns the request thread.
5720        """
5721        kwargs['_return_http_data_only'] = True
5722        if kwargs.get('callback'):
5723            return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5724        else:
5725            (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5726            return data
5727
5728    def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
5729        """
5730        Sets a signature, initials, or stamps image.
5731        
5732        This method makes a synchronous HTTP request by default. To make an
5733        asynchronous HTTP request, please define a `callback` function
5734        to be invoked when receiving the response.
5735        >>> def callback_function(response):
5736        >>>     pprint(response)
5737        >>>
5738        >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
5739
5740        :param callback function: The callback function
5741            for asynchronous request. (optional)
5742        :param str account_id: The external account number (int) or account ID Guid. (required)
5743        :param str image_type: One of **signature_image** or **initials_image**. (required)
5744        :param str signature_id: The ID of the signature being accessed. (required)
5745        :param str transparent_png:
5746        :return: AccountSignature
5747                 If the method is called asynchronously,
5748                 returns the request thread.
5749        """
5750
5751        all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png']
5752        all_params.append('callback')
5753        all_params.append('_return_http_data_only')
5754        all_params.append('_preload_content')
5755        all_params.append('_request_timeout')
5756
5757        params = locals()
5758        for key, val in iteritems(params['kwargs']):
5759            if key not in all_params:
5760                raise TypeError(
5761                    "Got an unexpected keyword argument '%s'"
5762                    " to method update_account_signature_image" % key
5763                )
5764            params[key] = val
5765        del params['kwargs']
5766        # verify the required parameter 'account_id' is set
5767        if ('account_id' not in params) or (params['account_id'] is None):
5768            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`")
5769        # verify the required parameter 'image_type' is set
5770        if ('image_type' not in params) or (params['image_type'] is None):
5771            raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`")
5772        # verify the required parameter 'signature_id' is set
5773        if ('signature_id' not in params) or (params['signature_id'] is None):
5774            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`")
5775
5776
5777        collection_formats = {}
5778
5779        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
5780        path_params = {}
5781        if 'account_id' in params:
5782            path_params['accountId'] = params['account_id']
5783        if 'image_type' in params:
5784            path_params['imageType'] = params['image_type']
5785        if 'signature_id' in params:
5786            path_params['signatureId'] = params['signature_id']
5787
5788        query_params = {}
5789        if 'transparent_png' in params:
5790            query_params['transparent_png'] = params['transparent_png']
5791
5792        header_params = {}
5793
5794        form_params = []
5795        local_var_files = {}
5796
5797        body_params = None
5798        # HTTP header `Accept`
5799        header_params['Accept'] = self.api_client.\
5800            select_header_accept(['application/json'])
5801
5802        # HTTP header `Content-Type`
5803        header_params['Content-Type'] = self.api_client.\
5804            select_header_content_type(['image/gif'])
5805
5806        # Authentication setting
5807        auth_settings = []
5808
5809        return self.api_client.call_api(resource_path, 'PUT',
5810                                        path_params,
5811                                        query_params,
5812                                        header_params,
5813                                        body=body_params,
5814                                        post_params=form_params,
5815                                        files=local_var_files,
5816                                        response_type='AccountSignature',
5817                                        auth_settings=auth_settings,
5818                                        callback=params.get('callback'),
5819                                        _return_http_data_only=params.get('_return_http_data_only'),
5820                                        _preload_content=params.get('_preload_content', True),
5821                                        _request_timeout=params.get('_request_timeout'),
5822                                        collection_formats=collection_formats)
5823
5824    def update_account_tab_settings(self, account_id, **kwargs):
5825        """
5826        Modifies tab settings for specified account
5827        This method modifies the tab types and tab functionality that is enabled for an account.
5828        This method makes a synchronous HTTP request by default. To make an
5829        asynchronous HTTP request, please define a `callback` function
5830        to be invoked when receiving the response.
5831        >>> def callback_function(response):
5832        >>>     pprint(response)
5833        >>>
5834        >>> thread = api.update_account_tab_settings(account_id, callback=callback_function)
5835
5836        :param callback function: The callback function
5837            for asynchronous request. (optional)
5838        :param str account_id: The external account number (int) or account ID Guid. (required)
5839        :param TabAccountSettings tab_account_settings:
5840        :return: TabAccountSettings
5841                 If the method is called asynchronously,
5842                 returns the request thread.
5843        """
5844        kwargs['_return_http_data_only'] = True
5845        if kwargs.get('callback'):
5846            return self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5847        else:
5848            (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5849            return data
5850
5851    def update_account_tab_settings_with_http_info(self, account_id, **kwargs):
5852        """
5853        Modifies tab settings for specified account
5854        This method modifies the tab types and tab functionality that is enabled for an account.
5855        This method makes a synchronous HTTP request by default. To make an
5856        asynchronous HTTP request, please define a `callback` function
5857        to be invoked when receiving the response.
5858        >>> def callback_function(response):
5859        >>>     pprint(response)
5860        >>>
5861        >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function)
5862
5863        :param callback function: The callback function
5864            for asynchronous request. (optional)
5865        :param str account_id: The external account number (int) or account ID Guid. (required)
5866        :param TabAccountSettings tab_account_settings:
5867        :return: TabAccountSettings
5868                 If the method is called asynchronously,
5869                 returns the request thread.
5870        """
5871
5872        all_params = ['account_id', 'tab_account_settings']
5873        all_params.append('callback')
5874        all_params.append('_return_http_data_only')
5875        all_params.append('_preload_content')
5876        all_params.append('_request_timeout')
5877
5878        params = locals()
5879        for key, val in iteritems(params['kwargs']):
5880            if key not in all_params:
5881                raise TypeError(
5882                    "Got an unexpected keyword argument '%s'"
5883                    " to method update_account_tab_settings" % key
5884                )
5885            params[key] = val
5886        del params['kwargs']
5887        # verify the required parameter 'account_id' is set
5888        if ('account_id' not in params) or (params['account_id'] is None):
5889            raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`")
5890
5891
5892        collection_formats = {}
5893
5894        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
5895        path_params = {}
5896        if 'account_id' in params:
5897            path_params['accountId'] = params['account_id']
5898
5899        query_params = {}
5900
5901        header_params = {}
5902
5903        form_params = []
5904        local_var_files = {}
5905
5906        body_params = None
5907        if 'tab_account_settings' in params:
5908            body_params = params['tab_account_settings']
5909        # HTTP header `Accept`
5910        header_params['Accept'] = self.api_client.\
5911            select_header_accept(['application/json'])
5912
5913        # Authentication setting
5914        auth_settings = []
5915
5916        return self.api_client.call_api(resource_path, 'PUT',
5917                                        path_params,
5918                                        query_params,
5919                                        header_params,
5920                                        body=body_params,
5921                                        post_params=form_params,
5922                                        files=local_var_files,
5923                                        response_type='TabAccountSettings',
5924                                        auth_settings=auth_settings,
5925                                        callback=params.get('callback'),
5926                                        _return_http_data_only=params.get('_return_http_data_only'),
5927                                        _preload_content=params.get('_preload_content', True),
5928                                        _request_timeout=params.get('_request_timeout'),
5929                                        collection_formats=collection_formats)
5930
5931    def update_brand(self, account_id, brand_id, **kwargs):
5932        """
5933        Updates an existing brand.
5934        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5935        This method makes a synchronous HTTP request by default. To make an
5936        asynchronous HTTP request, please define a `callback` function
5937        to be invoked when receiving the response.
5938        >>> def callback_function(response):
5939        >>>     pprint(response)
5940        >>>
5941        >>> thread = api.update_brand(account_id, brand_id, callback=callback_function)
5942
5943        :param callback function: The callback function
5944            for asynchronous request. (optional)
5945        :param str account_id: The external account number (int) or account ID Guid. (required)
5946        :param str brand_id: The unique identifier of a brand. (required)
5947        :param str replace_brand:
5948        :param Brand brand:
5949        :return: Brand
5950                 If the method is called asynchronously,
5951                 returns the request thread.
5952        """
5953        kwargs['_return_http_data_only'] = True
5954        if kwargs.get('callback'):
5955            return self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5956        else:
5957            (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5958            return data
5959
5960    def update_brand_with_http_info(self, account_id, brand_id, **kwargs):
5961        """
5962        Updates an existing brand.
5963        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5964        This method makes a synchronous HTTP request by default. To make an
5965        asynchronous HTTP request, please define a `callback` function
5966        to be invoked when receiving the response.
5967        >>> def callback_function(response):
5968        >>>     pprint(response)
5969        >>>
5970        >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
5971
5972        :param callback function: The callback function
5973            for asynchronous request. (optional)
5974        :param str account_id: The external account number (int) or account ID Guid. (required)
5975        :param str brand_id: The unique identifier of a brand. (required)
5976        :param str replace_brand:
5977        :param Brand brand:
5978        :return: Brand
5979                 If the method is called asynchronously,
5980                 returns the request thread.
5981        """
5982
5983        all_params = ['account_id', 'brand_id', 'replace_brand', 'brand']
5984        all_params.append('callback')
5985        all_params.append('_return_http_data_only')
5986        all_params.append('_preload_content')
5987        all_params.append('_request_timeout')
5988
5989        params = locals()
5990        for key, val in iteritems(params['kwargs']):
5991            if key not in all_params:
5992                raise TypeError(
5993                    "Got an unexpected keyword argument '%s'"
5994                    " to method update_brand" % key
5995                )
5996            params[key] = val
5997        del params['kwargs']
5998        # verify the required parameter 'account_id' is set
5999        if ('account_id' not in params) or (params['account_id'] is None):
6000            raise ValueError("Missing the required parameter `account_id` when calling `update_brand`")
6001        # verify the required parameter 'brand_id' is set
6002        if ('brand_id' not in params) or (params['brand_id'] is None):
6003            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`")
6004
6005
6006        collection_formats = {}
6007
6008        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
6009        path_params = {}
6010        if 'account_id' in params:
6011            path_params['accountId'] = params['account_id']
6012        if 'brand_id' in params:
6013            path_params['brandId'] = params['brand_id']
6014
6015        query_params = {}
6016        if 'replace_brand' in params:
6017            query_params['replace_brand'] = params['replace_brand']
6018
6019        header_params = {}
6020
6021        form_params = []
6022        local_var_files = {}
6023
6024        body_params = None
6025        if 'brand' in params:
6026            body_params = params['brand']
6027        # HTTP header `Accept`
6028        header_params['Accept'] = self.api_client.\
6029            select_header_accept(['application/json'])
6030
6031        # Authentication setting
6032        auth_settings = []
6033
6034        return self.api_client.call_api(resource_path, 'PUT',
6035                                        path_params,
6036                                        query_params,
6037                                        header_params,
6038                                        body=body_params,
6039                                        post_params=form_params,
6040                                        files=local_var_files,
6041                                        response_type='Brand',
6042                                        auth_settings=auth_settings,
6043                                        callback=params.get('callback'),
6044                                        _return_http_data_only=params.get('_return_http_data_only'),
6045                                        _preload_content=params.get('_preload_content', True),
6046                                        _request_timeout=params.get('_request_timeout'),
6047                                        collection_formats=collection_formats)
6048
6049    def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6050        """
6051        Put one branding logo.
6052        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6053        This method makes a synchronous HTTP request by default. To make an
6054        asynchronous HTTP request, please define a `callback` function
6055        to be invoked when receiving the response.
6056        >>> def callback_function(response):
6057        >>>     pprint(response)
6058        >>>
6059        >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6060
6061        :param callback function: The callback function
6062            for asynchronous request. (optional)
6063        :param str account_id: The external account number (int) or account ID GUID. (required)
6064        :param str brand_id: The ID of the brand. (required)
6065        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6066        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6067        :return: None
6068                 If the method is called asynchronously,
6069                 returns the request thread.
6070        """
6071        kwargs['_return_http_data_only'] = True
6072        if kwargs.get('callback'):
6073            return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6074        else:
6075            (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6076            return data
6077
6078    def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6079        """
6080        Put one branding logo.
6081        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6082        This method makes a synchronous HTTP request by default. To make an
6083        asynchronous HTTP request, please define a `callback` function
6084        to be invoked when receiving the response.
6085        >>> def callback_function(response):
6086        >>>     pprint(response)
6087        >>>
6088        >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6089
6090        :param callback function: The callback function
6091            for asynchronous request. (optional)
6092        :param str account_id: The external account number (int) or account ID GUID. (required)
6093        :param str brand_id: The ID of the brand. (required)
6094        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6095        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6096        :return: None
6097                 If the method is called asynchronously,
6098                 returns the request thread.
6099        """
6100
6101        all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes']
6102        all_params.append('callback')
6103        all_params.append('_return_http_data_only')
6104        all_params.append('_preload_content')
6105        all_params.append('_request_timeout')
6106
6107        params = locals()
6108        for key, val in iteritems(params['kwargs']):
6109            if key not in all_params:
6110                raise TypeError(
6111                    "Got an unexpected keyword argument '%s'"
6112                    " to method update_brand_logo_by_type" % key
6113                )
6114            params[key] = val
6115        del params['kwargs']
6116        # verify the required parameter 'account_id' is set
6117        if ('account_id' not in params) or (params['account_id'] is None):
6118            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`")
6119        # verify the required parameter 'brand_id' is set
6120        if ('brand_id' not in params) or (params['brand_id'] is None):
6121            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`")
6122        # verify the required parameter 'logo_type' is set
6123        if ('logo_type' not in params) or (params['logo_type'] is None):
6124            raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`")
6125        # verify the required parameter 'logo_file_bytes' is set
6126        if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None):
6127            raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`")
6128
6129
6130        collection_formats = {}
6131
6132        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
6133        path_params = {}
6134        if 'account_id' in params:
6135            path_params['accountId'] = params['account_id']
6136        if 'brand_id' in params:
6137            path_params['brandId'] = params['brand_id']
6138        if 'logo_type' in params:
6139            path_params['logoType'] = params['logo_type']
6140
6141        query_params = {}
6142
6143        header_params = {}
6144
6145        form_params = []
6146        local_var_files = {}
6147
6148        body_params = None
6149        if 'logo_file_bytes' in params:
6150            body_params = params['logo_file_bytes']
6151        # HTTP header `Accept`
6152        header_params['Accept'] = self.api_client.\
6153            select_header_accept(['application/json'])
6154
6155        # HTTP header `Content-Type`
6156        header_params['Content-Type'] = self.api_client.\
6157            select_header_content_type(['image/png'])
6158
6159        # Authentication setting
6160        auth_settings = []
6161
6162        return self.api_client.call_api(resource_path, 'PUT',
6163                                        path_params,
6164                                        query_params,
6165                                        header_params,
6166                                        body=body_params,
6167                                        post_params=form_params,
6168                                        files=local_var_files,
6169                                        response_type=None,
6170                                        auth_settings=auth_settings,
6171                                        callback=params.get('callback'),
6172                                        _return_http_data_only=params.get('_return_http_data_only'),
6173                                        _preload_content=params.get('_preload_content', True),
6174                                        _request_timeout=params.get('_request_timeout'),
6175                                        collection_formats=collection_formats)
6176
6177    def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6178        """
6179        Uploads a branding resource file.
6180        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6181        This method makes a synchronous HTTP request by default. To make an
6182        asynchronous HTTP request, please define a `callback` function
6183        to be invoked when receiving the response.
6184        >>> def callback_function(response):
6185        >>>     pprint(response)
6186        >>>
6187        >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6188
6189        :param callback function: The callback function
6190            for asynchronous request. (optional)
6191        :param str account_id: The external account number (int) or account ID GUID. (required)
6192        :param str brand_id: The ID of the brand. (required)
6193        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6194        :param file file_xml: Brand resource XML file. (required)
6195        :return: BrandResources
6196                 If the method is called asynchronously,
6197                 returns the request thread.
6198        """
6199        kwargs['_return_http_data_only'] = True
6200        if kwargs.get('callback'):
6201            return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6202        else:
6203            (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6204            return data
6205
6206    def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6207        """
6208        Uploads a branding resource file.
6209        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6210        This method makes a synchronous HTTP request by default. To make an
6211        asynchronous HTTP request, please define a `callback` function
6212        to be invoked when receiving the response.
6213        >>> def callback_function(response):
6214        >>>     pprint(response)
6215        >>>
6216        >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6217
6218        :param callback function: The callback function
6219            for asynchronous request. (optional)
6220        :param str account_id: The external account number (int) or account ID GUID. (required)
6221        :param str brand_id: The ID of the brand. (required)
6222        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6223        :param file file_xml: Brand resource XML file. (required)
6224        :return: BrandResources
6225                 If the method is called asynchronously,
6226                 returns the request thread.
6227        """
6228
6229        all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml']
6230        all_params.append('callback')
6231        all_params.append('_return_http_data_only')
6232        all_params.append('_preload_content')
6233        all_params.append('_request_timeout')
6234
6235        params = locals()
6236        for key, val in iteritems(params['kwargs']):
6237            if key not in all_params:
6238                raise TypeError(
6239                    "Got an unexpected keyword argument '%s'"
6240                    " to method update_brand_resources_by_content_type" % key
6241                )
6242            params[key] = val
6243        del params['kwargs']
6244        # verify the required parameter 'account_id' is set
6245        if ('account_id' not in params) or (params['account_id'] is None):
6246            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`")
6247        # verify the required parameter 'brand_id' is set
6248        if ('brand_id' not in params) or (params['brand_id'] is None):
6249            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`")
6250        # verify the required parameter 'resource_content_type' is set
6251        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
6252            raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`")
6253        # verify the required parameter 'file_xml' is set
6254        if ('file_xml' not in params) or (params['file_xml'] is None):
6255            raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`")
6256
6257
6258        collection_formats = {}
6259
6260        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
6261        path_params = {}
6262        if 'account_id' in params:
6263            path_params['accountId'] = params['account_id']
6264        if 'brand_id' in params:
6265            path_params['brandId'] = params['brand_id']
6266        if 'resource_content_type' in params:
6267            path_params['resourceContentType'] = params['resource_content_type']
6268
6269        query_params = {}
6270
6271        header_params = {}
6272
6273        form_params = []
6274        local_var_files = {}
6275        if 'file_xml' in params:
6276            local_var_files['file.xml'] = params['file_xml']
6277
6278        body_params = None
6279        # HTTP header `Accept`
6280        header_params['Accept'] = self.api_client.\
6281            select_header_accept(['application/json'])
6282
6283        # HTTP header `Content-Type`
6284        header_params['Content-Type'] = self.api_client.\
6285            select_header_content_type(['multipart/form-data'])
6286
6287        # Authentication setting
6288        auth_settings = []
6289
6290        return self.api_client.call_api(resource_path, 'PUT',
6291                                        path_params,
6292                                        query_params,
6293                                        header_params,
6294                                        body=body_params,
6295                                        post_params=form_params,
6296                                        files=local_var_files,
6297                                        response_type='BrandResources',
6298                                        auth_settings=auth_settings,
6299                                        callback=params.get('callback'),
6300                                        _return_http_data_only=params.get('_return_http_data_only'),
6301                                        _preload_content=params.get('_preload_content', True),
6302                                        _request_timeout=params.get('_request_timeout'),
6303                                        collection_formats=collection_formats)
6304
6305    def update_consumer_disclosure(self, account_id, lang_code, **kwargs):
6306        """
6307        Update Consumer Disclosure.
6308        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6309        This method makes a synchronous HTTP request by default. To make an
6310        asynchronous HTTP request, please define a `callback` function
6311        to be invoked when receiving the response.
6312        >>> def callback_function(response):
6313        >>>     pprint(response)
6314        >>>
6315        >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function)
6316
6317        :param callback function: The callback function
6318            for asynchronous request. (optional)
6319        :param str account_id: The external account number (int) or account ID Guid. (required)
6320        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6321        :param str include_metadata:
6322        :param ConsumerDisclosure consumer_disclosure:
6323        :return: ConsumerDisclosure
6324                 If the method is called asynchronously,
6325                 returns the request thread.
6326        """
6327        kwargs['_return_http_data_only'] = True
6328        if kwargs.get('callback'):
6329            return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6330        else:
6331            (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6332            return data
6333
6334    def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
6335        """
6336        Update Consumer Disclosure.
6337        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6338        This method makes a synchronous HTTP request by default. To make an
6339        asynchronous HTTP request, please define a `callback` function
6340        to be invoked when receiving the response.
6341        >>> def callback_function(response):
6342        >>>     pprint(response)
6343        >>>
6344        >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
6345
6346        :param callback function: The callback function
6347            for asynchronous request. (optional)
6348        :param str account_id: The external account number (int) or account ID Guid. (required)
6349        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6350        :param str include_metadata:
6351        :param ConsumerDisclosure consumer_disclosure:
6352        :return: ConsumerDisclosure
6353                 If the method is called asynchronously,
6354                 returns the request thread.
6355        """
6356
6357        all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure']
6358        all_params.append('callback')
6359        all_params.append('_return_http_data_only')
6360        all_params.append('_preload_content')
6361        all_params.append('_request_timeout')
6362
6363        params = locals()
6364        for key, val in iteritems(params['kwargs']):
6365            if key not in all_params:
6366                raise TypeError(
6367                    "Got an unexpected keyword argument '%s'"
6368                    " to method update_consumer_disclosure" % key
6369                )
6370            params[key] = val
6371        del params['kwargs']
6372        # verify the required parameter 'account_id' is set
6373        if ('account_id' not in params) or (params['account_id'] is None):
6374            raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`")
6375        # verify the required parameter 'lang_code' is set
6376        if ('lang_code' not in params) or (params['lang_code'] is None):
6377            raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`")
6378
6379
6380        collection_formats = {}
6381
6382        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
6383        path_params = {}
6384        if 'account_id' in params:
6385            path_params['accountId'] = params['account_id']
6386        if 'lang_code' in params:
6387            path_params['langCode'] = params['lang_code']
6388
6389        query_params = {}
6390        if 'include_metadata' in params:
6391            query_params['include_metadata'] = params['include_metadata']
6392
6393        header_params = {}
6394
6395        form_params = []
6396        local_var_files = {}
6397
6398        body_params = None
6399        if 'consumer_disclosure' in params:
6400            body_params = params['consumer_disclosure']
6401        # HTTP header `Accept`
6402        header_params['Accept'] = self.api_client.\
6403            select_header_accept(['application/json'])
6404
6405        # Authentication setting
6406        auth_settings = []
6407
6408        return self.api_client.call_api(resource_path, 'PUT',
6409                                        path_params,
6410                                        query_params,
6411                                        header_params,
6412                                        body=body_params,
6413                                        post_params=form_params,
6414                                        files=local_var_files,
6415                                        response_type='ConsumerDisclosure',
6416                                        auth_settings=auth_settings,
6417                                        callback=params.get('callback'),
6418                                        _return_http_data_only=params.get('_return_http_data_only'),
6419                                        _preload_content=params.get('_preload_content', True),
6420                                        _request_timeout=params.get('_request_timeout'),
6421                                        collection_formats=collection_formats)
6422
6423    def update_custom_field(self, account_id, custom_field_id, **kwargs):
6424        """
6425        Updates an existing account custom field.
6426        This method updates an existing account custom field.
6427        This method makes a synchronous HTTP request by default. To make an
6428        asynchronous HTTP request, please define a `callback` function
6429        to be invoked when receiving the response.
6430        >>> def callback_function(response):
6431        >>>     pprint(response)
6432        >>>
6433        >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function)
6434
6435        :param callback function: The callback function
6436            for asynchronous request. (optional)
6437        :param str account_id: The external account number (int) or account ID Guid. (required)
6438        :param str custom_field_id: (required)
6439        :param str apply_to_templates:
6440        :param CustomField custom_field:
6441        :return: CustomFields
6442                 If the method is called asynchronously,
6443                 returns the request thread.
6444        """
6445        kwargs['_return_http_data_only'] = True
6446        if kwargs.get('callback'):
6447            return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6448        else:
6449            (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6450            return data
6451
6452    def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
6453        """
6454        Updates an existing account custom field.
6455        This method updates an existing account custom field.
6456        This method makes a synchronous HTTP request by default. To make an
6457        asynchronous HTTP request, please define a `callback` function
6458        to be invoked when receiving the response.
6459        >>> def callback_function(response):
6460        >>>     pprint(response)
6461        >>>
6462        >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
6463
6464        :param callback function: The callback function
6465            for asynchronous request. (optional)
6466        :param str account_id: The external account number (int) or account ID Guid. (required)
6467        :param str custom_field_id: (required)
6468        :param str apply_to_templates:
6469        :param CustomField custom_field:
6470        :return: CustomFields
6471                 If the method is called asynchronously,
6472                 returns the request thread.
6473        """
6474
6475        all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field']
6476        all_params.append('callback')
6477        all_params.append('_return_http_data_only')
6478        all_params.append('_preload_content')
6479        all_params.append('_request_timeout')
6480
6481        params = locals()
6482        for key, val in iteritems(params['kwargs']):
6483            if key not in all_params:
6484                raise TypeError(
6485                    "Got an unexpected keyword argument '%s'"
6486                    " to method update_custom_field" % key
6487                )
6488            params[key] = val
6489        del params['kwargs']
6490        # verify the required parameter 'account_id' is set
6491        if ('account_id' not in params) or (params['account_id'] is None):
6492            raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`")
6493        # verify the required parameter 'custom_field_id' is set
6494        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
6495            raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`")
6496
6497
6498        collection_formats = {}
6499
6500        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
6501        path_params = {}
6502        if 'account_id' in params:
6503            path_params['accountId'] = params['account_id']
6504        if 'custom_field_id' in params:
6505            path_params['customFieldId'] = params['custom_field_id']
6506
6507        query_params = {}
6508        if 'apply_to_templates' in params:
6509            query_params['apply_to_templates'] = params['apply_to_templates']
6510
6511        header_params = {}
6512
6513        form_params = []
6514        local_var_files = {}
6515
6516        body_params = None
6517        if 'custom_field' in params:
6518            body_params = params['custom_field']
6519        # HTTP header `Accept`
6520        header_params['Accept'] = self.api_client.\
6521            select_header_accept(['application/json'])
6522
6523        # Authentication setting
6524        auth_settings = []
6525
6526        return self.api_client.call_api(resource_path, 'PUT',
6527                                        path_params,
6528                                        query_params,
6529                                        header_params,
6530                                        body=body_params,
6531                                        post_params=form_params,
6532                                        files=local_var_files,
6533                                        response_type='CustomFields',
6534                                        auth_settings=auth_settings,
6535                                        callback=params.get('callback'),
6536                                        _return_http_data_only=params.get('_return_http_data_only'),
6537                                        _preload_content=params.get('_preload_content', True),
6538                                        _request_timeout=params.get('_request_timeout'),
6539                                        collection_formats=collection_formats)
6540
6541    def update_e_note_configuration(self, account_id, **kwargs):
6542        """
6543        Updates configuration information for the eNote eOriginal integration.
6544        
6545        This method makes a synchronous HTTP request by default. To make an
6546        asynchronous HTTP request, please define a `callback` function
6547        to be invoked when receiving the response.
6548        >>> def callback_function(response):
6549        >>>     pprint(response)
6550        >>>
6551        >>> thread = api.update_e_note_configuration(account_id, callback=callback_function)
6552
6553        :param callback function: The callback function
6554            for asynchronous request. (optional)
6555        :param str account_id: The external account number (int) or account ID Guid. (required)
6556        :param ENoteConfiguration e_note_configuration:
6557        :return: ENoteConfiguration
6558                 If the method is called asynchronously,
6559                 returns the request thread.
6560        """
6561        kwargs['_return_http_data_only'] = True
6562        if kwargs.get('callback'):
6563            return self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6564        else:
6565            (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6566            return data
6567
6568    def update_e_note_configuration_with_http_info(self, account_id, **kwargs):
6569        """
6570        Updates configuration information for the eNote eOriginal integration.
6571        
6572        This method makes a synchronous HTTP request by default. To make an
6573        asynchronous HTTP request, please define a `callback` function
6574        to be invoked when receiving the response.
6575        >>> def callback_function(response):
6576        >>>     pprint(response)
6577        >>>
6578        >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function)
6579
6580        :param callback function: The callback function
6581            for asynchronous request. (optional)
6582        :param str account_id: The external account number (int) or account ID Guid. (required)
6583        :param ENoteConfiguration e_note_configuration:
6584        :return: ENoteConfiguration
6585                 If the method is called asynchronously,
6586                 returns the request thread.
6587        """
6588
6589        all_params = ['account_id', 'e_note_configuration']
6590        all_params.append('callback')
6591        all_params.append('_return_http_data_only')
6592        all_params.append('_preload_content')
6593        all_params.append('_request_timeout')
6594
6595        params = locals()
6596        for key, val in iteritems(params['kwargs']):
6597            if key not in all_params:
6598                raise TypeError(
6599                    "Got an unexpected keyword argument '%s'"
6600                    " to method update_e_note_configuration" % key
6601                )
6602            params[key] = val
6603        del params['kwargs']
6604        # verify the required parameter 'account_id' is set
6605        if ('account_id' not in params) or (params['account_id'] is None):
6606            raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`")
6607
6608
6609        collection_formats = {}
6610
6611        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
6612        path_params = {}
6613        if 'account_id' in params:
6614            path_params['accountId'] = params['account_id']
6615
6616        query_params = {}
6617
6618        header_params = {}
6619
6620        form_params = []
6621        local_var_files = {}
6622
6623        body_params = None
6624        if 'e_note_configuration' in params:
6625            body_params = params['e_note_configuration']
6626        # HTTP header `Accept`
6627        header_params['Accept'] = self.api_client.\
6628            select_header_accept(['application/json'])
6629
6630        # Authentication setting
6631        auth_settings = []
6632
6633        return self.api_client.call_api(resource_path, 'PUT',
6634                                        path_params,
6635                                        query_params,
6636                                        header_params,
6637                                        body=body_params,
6638                                        post_params=form_params,
6639                                        files=local_var_files,
6640                                        response_type='ENoteConfiguration',
6641                                        auth_settings=auth_settings,
6642                                        callback=params.get('callback'),
6643                                        _return_http_data_only=params.get('_return_http_data_only'),
6644                                        _preload_content=params.get('_preload_content', True),
6645                                        _request_timeout=params.get('_request_timeout'),
6646                                        collection_formats=collection_formats)
6647
6648    def update_envelope_purge_configuration(self, account_id, **kwargs):
6649        """
6650        Updates envelope purge configuration.
6651        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6652        This method makes a synchronous HTTP request by default. To make an
6653        asynchronous HTTP request, please define a `callback` function
6654        to be invoked when receiving the response.
6655        >>> def callback_function(response):
6656        >>>     pprint(response)
6657        >>>
6658        >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function)
6659
6660        :param callback function: The callback function
6661            for asynchronous request. (optional)
6662        :param str account_id: The external account number (int) or account ID Guid. (required)
6663        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6664        :return: EnvelopePurgeConfiguration
6665                 If the method is called asynchronously,
6666                 returns the request thread.
6667        """
6668        kwargs['_return_http_data_only'] = True
6669        if kwargs.get('callback'):
6670            return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6671        else:
6672            (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6673            return data
6674
6675    def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
6676        """
6677        Updates envelope purge configuration.
6678        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6679        This method makes a synchronous HTTP request by default. To make an
6680        asynchronous HTTP request, please define a `callback` function
6681        to be invoked when receiving the response.
6682        >>> def callback_function(response):
6683        >>>     pprint(response)
6684        >>>
6685        >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
6686
6687        :param callback function: The callback function
6688            for asynchronous request. (optional)
6689        :param str account_id: The external account number (int) or account ID Guid. (required)
6690        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6691        :return: EnvelopePurgeConfiguration
6692                 If the method is called asynchronously,
6693                 returns the request thread.
6694        """
6695
6696        all_params = ['account_id', 'envelope_purge_configuration']
6697        all_params.append('callback')
6698        all_params.append('_return_http_data_only')
6699        all_params.append('_preload_content')
6700        all_params.append('_request_timeout')
6701
6702        params = locals()
6703        for key, val in iteritems(params['kwargs']):
6704            if key not in all_params:
6705                raise TypeError(
6706                    "Got an unexpected keyword argument '%s'"
6707                    " to method update_envelope_purge_configuration" % key
6708                )
6709            params[key] = val
6710        del params['kwargs']
6711        # verify the required parameter 'account_id' is set
6712        if ('account_id' not in params) or (params['account_id'] is None):
6713            raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`")
6714
6715
6716        collection_formats = {}
6717
6718        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
6719        path_params = {}
6720        if 'account_id' in params:
6721            path_params['accountId'] = params['account_id']
6722
6723        query_params = {}
6724
6725        header_params = {}
6726
6727        form_params = []
6728        local_var_files = {}
6729
6730        body_params = None
6731        if 'envelope_purge_configuration' in params:
6732            body_params = params['envelope_purge_configuration']
6733        # HTTP header `Accept`
6734        header_params['Accept'] = self.api_client.\
6735            select_header_accept(['application/json'])
6736
6737        # Authentication setting
6738        auth_settings = []
6739
6740        return self.api_client.call_api(resource_path, 'PUT',
6741                                        path_params,
6742                                        query_params,
6743                                        header_params,
6744                                        body=body_params,
6745                                        post_params=form_params,
6746                                        files=local_var_files,
6747                                        response_type='EnvelopePurgeConfiguration',
6748                                        auth_settings=auth_settings,
6749                                        callback=params.get('callback'),
6750                                        _return_http_data_only=params.get('_return_http_data_only'),
6751                                        _preload_content=params.get('_preload_content', True),
6752                                        _request_timeout=params.get('_request_timeout'),
6753                                        collection_formats=collection_formats)
6754
6755    def update_favorite_template(self, account_id, **kwargs):
6756        """
6757        Favorites a template
6758        
6759        This method makes a synchronous HTTP request by default. To make an
6760        asynchronous HTTP request, please define a `callback` function
6761        to be invoked when receiving the response.
6762        >>> def callback_function(response):
6763        >>>     pprint(response)
6764        >>>
6765        >>> thread = api.update_favorite_template(account_id, callback=callback_function)
6766
6767        :param callback function: The callback function
6768            for asynchronous request. (optional)
6769        :param str account_id: The external account number (int) or account ID Guid. (required)
6770        :param FavoriteTemplatesInfo favorite_templates_info:
6771        :return: FavoriteTemplatesInfo
6772                 If the method is called asynchronously,
6773                 returns the request thread.
6774        """
6775        kwargs['_return_http_data_only'] = True
6776        if kwargs.get('callback'):
6777            return self.update_favorite_template_with_http_info(account_id, **kwargs)
6778        else:
6779            (data) = self.update_favorite_template_with_http_info(account_id, **kwargs)
6780            return data
6781
6782    def update_favorite_template_with_http_info(self, account_id, **kwargs):
6783        """
6784        Favorites a template
6785        
6786        This method makes a synchronous HTTP request by default. To make an
6787        asynchronous HTTP request, please define a `callback` function
6788        to be invoked when receiving the response.
6789        >>> def callback_function(response):
6790        >>>     pprint(response)
6791        >>>
6792        >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function)
6793
6794        :param callback function: The callback function
6795            for asynchronous request. (optional)
6796        :param str account_id: The external account number (int) or account ID Guid. (required)
6797        :param FavoriteTemplatesInfo favorite_templates_info:
6798        :return: FavoriteTemplatesInfo
6799                 If the method is called asynchronously,
6800                 returns the request thread.
6801        """
6802
6803        all_params = ['account_id', 'favorite_templates_info']
6804        all_params.append('callback')
6805        all_params.append('_return_http_data_only')
6806        all_params.append('_preload_content')
6807        all_params.append('_request_timeout')
6808
6809        params = locals()
6810        for key, val in iteritems(params['kwargs']):
6811            if key not in all_params:
6812                raise TypeError(
6813                    "Got an unexpected keyword argument '%s'"
6814                    " to method update_favorite_template" % key
6815                )
6816            params[key] = val
6817        del params['kwargs']
6818        # verify the required parameter 'account_id' is set
6819        if ('account_id' not in params) or (params['account_id'] is None):
6820            raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`")
6821
6822
6823        collection_formats = {}
6824
6825        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
6826        path_params = {}
6827        if 'account_id' in params:
6828            path_params['accountId'] = params['account_id']
6829
6830        query_params = {}
6831
6832        header_params = {}
6833
6834        form_params = []
6835        local_var_files = {}
6836
6837        body_params = None
6838        if 'favorite_templates_info' in params:
6839            body_params = params['favorite_templates_info']
6840        # HTTP header `Accept`
6841        header_params['Accept'] = self.api_client.\
6842            select_header_accept(['application/json'])
6843
6844        # Authentication setting
6845        auth_settings = []
6846
6847        return self.api_client.call_api(resource_path, 'PUT',
6848                                        path_params,
6849                                        query_params,
6850                                        header_params,
6851                                        body=body_params,
6852                                        post_params=form_params,
6853                                        files=local_var_files,
6854                                        response_type='FavoriteTemplatesInfo',
6855                                        auth_settings=auth_settings,
6856                                        callback=params.get('callback'),
6857                                        _return_http_data_only=params.get('_return_http_data_only'),
6858                                        _preload_content=params.get('_preload_content', True),
6859                                        _request_timeout=params.get('_request_timeout'),
6860                                        collection_formats=collection_formats)
6861
6862    def update_notification_defaults(self, account_id, **kwargs):
6863        """
6864        Updates default user level settings for a specified account
6865        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6866        This method makes a synchronous HTTP request by default. To make an
6867        asynchronous HTTP request, please define a `callback` function
6868        to be invoked when receiving the response.
6869        >>> def callback_function(response):
6870        >>>     pprint(response)
6871        >>>
6872        >>> thread = api.update_notification_defaults(account_id, callback=callback_function)
6873
6874        :param callback function: The callback function
6875            for asynchronous request. (optional)
6876        :param str account_id: The external account number (int) or account ID Guid. (required)
6877        :param NotificationDefaults notification_defaults:
6878        :return: NotificationDefaults
6879                 If the method is called asynchronously,
6880                 returns the request thread.
6881        """
6882        kwargs['_return_http_data_only'] = True
6883        if kwargs.get('callback'):
6884            return self.update_notification_defaults_with_http_info(account_id, **kwargs)
6885        else:
6886            (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs)
6887            return data
6888
6889    def update_notification_defaults_with_http_info(self, account_id, **kwargs):
6890        """
6891        Updates default user level settings for a specified account
6892        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6893        This method makes a synchronous HTTP request by default. To make an
6894        asynchronous HTTP request, please define a `callback` function
6895        to be invoked when receiving the response.
6896        >>> def callback_function(response):
6897        >>>     pprint(response)
6898        >>>
6899        >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function)
6900
6901        :param callback function: The callback function
6902            for asynchronous request. (optional)
6903        :param str account_id: The external account number (int) or account ID Guid. (required)
6904        :param NotificationDefaults notification_defaults:
6905        :return: NotificationDefaults
6906                 If the method is called asynchronously,
6907                 returns the request thread.
6908        """
6909
6910        all_params = ['account_id', 'notification_defaults']
6911        all_params.append('callback')
6912        all_params.append('_return_http_data_only')
6913        all_params.append('_preload_content')
6914        all_params.append('_request_timeout')
6915
6916        params = locals()
6917        for key, val in iteritems(params['kwargs']):
6918            if key not in all_params:
6919                raise TypeError(
6920                    "Got an unexpected keyword argument '%s'"
6921                    " to method update_notification_defaults" % key
6922                )
6923            params[key] = val
6924        del params['kwargs']
6925        # verify the required parameter 'account_id' is set
6926        if ('account_id' not in params) or (params['account_id'] is None):
6927            raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`")
6928
6929
6930        collection_formats = {}
6931
6932        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
6933        path_params = {}
6934        if 'account_id' in params:
6935            path_params['accountId'] = params['account_id']
6936
6937        query_params = {}
6938
6939        header_params = {}
6940
6941        form_params = []
6942        local_var_files = {}
6943
6944        body_params = None
6945        if 'notification_defaults' in params:
6946            body_params = params['notification_defaults']
6947        # HTTP header `Accept`
6948        header_params['Accept'] = self.api_client.\
6949            select_header_accept(['application/json'])
6950
6951        # Authentication setting
6952        auth_settings = []
6953
6954        return self.api_client.call_api(resource_path, 'PUT',
6955                                        path_params,
6956                                        query_params,
6957                                        header_params,
6958                                        body=body_params,
6959                                        post_params=form_params,
6960                                        files=local_var_files,
6961                                        response_type='NotificationDefaults',
6962                                        auth_settings=auth_settings,
6963                                        callback=params.get('callback'),
6964                                        _return_http_data_only=params.get('_return_http_data_only'),
6965                                        _preload_content=params.get('_preload_content', True),
6966                                        _request_timeout=params.get('_request_timeout'),
6967                                        collection_formats=collection_formats)
6968
6969    def update_password_rules(self, account_id, **kwargs):
6970        """
6971        Update the password rules
6972        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
6973        This method makes a synchronous HTTP request by default. To make an
6974        asynchronous HTTP request, please define a `callback` function
6975        to be invoked when receiving the response.
6976        >>> def callback_function(response):
6977        >>>     pprint(response)
6978        >>>
6979        >>> thread = api.update_password_rules(account_id, callback=callback_function)
6980
6981        :param callback function: The callback function
6982            for asynchronous request. (optional)
6983        :param str account_id: The external account number (int) or account ID Guid. (required)
6984        :param AccountPasswordRules account_password_rules:
6985        :return: AccountPasswordRules
6986                 If the method is called asynchronously,
6987                 returns the request thread.
6988        """
6989        kwargs['_return_http_data_only'] = True
6990        if kwargs.get('callback'):
6991            return self.update_password_rules_with_http_info(account_id, **kwargs)
6992        else:
6993            (data) = self.update_password_rules_with_http_info(account_id, **kwargs)
6994            return data
6995
6996    def update_password_rules_with_http_info(self, account_id, **kwargs):
6997        """
6998        Update the password rules
6999        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
7000        This method makes a synchronous HTTP request by default. To make an
7001        asynchronous HTTP request, please define a `callback` function
7002        to be invoked when receiving the response.
7003        >>> def callback_function(response):
7004        >>>     pprint(response)
7005        >>>
7006        >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function)
7007
7008        :param callback function: The callback function
7009            for asynchronous request. (optional)
7010        :param str account_id: The external account number (int) or account ID Guid. (required)
7011        :param AccountPasswordRules account_password_rules:
7012        :return: AccountPasswordRules
7013                 If the method is called asynchronously,
7014                 returns the request thread.
7015        """
7016
7017        all_params = ['account_id', 'account_password_rules']
7018        all_params.append('callback')
7019        all_params.append('_return_http_data_only')
7020        all_params.append('_preload_content')
7021        all_params.append('_request_timeout')
7022
7023        params = locals()
7024        for key, val in iteritems(params['kwargs']):
7025            if key not in all_params:
7026                raise TypeError(
7027                    "Got an unexpected keyword argument '%s'"
7028                    " to method update_password_rules" % key
7029                )
7030            params[key] = val
7031        del params['kwargs']
7032        # verify the required parameter 'account_id' is set
7033        if ('account_id' not in params) or (params['account_id'] is None):
7034            raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`")
7035
7036
7037        collection_formats = {}
7038
7039        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
7040        path_params = {}
7041        if 'account_id' in params:
7042            path_params['accountId'] = params['account_id']
7043
7044        query_params = {}
7045
7046        header_params = {}
7047
7048        form_params = []
7049        local_var_files = {}
7050
7051        body_params = None
7052        if 'account_password_rules' in params:
7053            body_params = params['account_password_rules']
7054        # HTTP header `Accept`
7055        header_params['Accept'] = self.api_client.\
7056            select_header_accept(['application/json'])
7057
7058        # Authentication setting
7059        auth_settings = []
7060
7061        return self.api_client.call_api(resource_path, 'PUT',
7062                                        path_params,
7063                                        query_params,
7064                                        header_params,
7065                                        body=body_params,
7066                                        post_params=form_params,
7067                                        files=local_var_files,
7068                                        response_type='AccountPasswordRules',
7069                                        auth_settings=auth_settings,
7070                                        callback=params.get('callback'),
7071                                        _return_http_data_only=params.get('_return_http_data_only'),
7072                                        _preload_content=params.get('_preload_content', True),
7073                                        _request_timeout=params.get('_request_timeout'),
7074                                        collection_formats=collection_formats)
7075
7076    def update_permission_profile(self, account_id, permission_profile_id, **kwargs):
7077        """
7078        Updates a permission profile within the specified account.
7079        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7080        This method makes a synchronous HTTP request by default. To make an
7081        asynchronous HTTP request, please define a `callback` function
7082        to be invoked when receiving the response.
7083        >>> def callback_function(response):
7084        >>>     pprint(response)
7085        >>>
7086        >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function)
7087
7088        :param callback function: The callback function
7089            for asynchronous request. (optional)
7090        :param str account_id: The external account number (int) or account ID Guid. (required)
7091        :param str permission_profile_id: (required)
7092        :param str include:
7093        :param PermissionProfile permission_profile:
7094        :return: PermissionProfile
7095                 If the method is called asynchronously,
7096                 returns the request thread.
7097        """
7098        kwargs['_return_http_data_only'] = True
7099        if kwargs.get('callback'):
7100            return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7101        else:
7102            (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7103            return data
7104
7105    def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
7106        """
7107        Updates a permission profile within the specified account.
7108        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7109        This method makes a synchronous HTTP request by default. To make an
7110        asynchronous HTTP request, please define a `callback` function
7111        to be invoked when receiving the response.
7112        >>> def callback_function(response):
7113        >>>     pprint(response)
7114        >>>
7115        >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
7116
7117        :param callback function: The callback function
7118            for asynchronous request. (optional)
7119        :param str account_id: The external account number (int) or account ID Guid. (required)
7120        :param str permission_profile_id: (required)
7121        :param str include:
7122        :param PermissionProfile permission_profile:
7123        :return: PermissionProfile
7124                 If the method is called asynchronously,
7125                 returns the request thread.
7126        """
7127
7128        all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile']
7129        all_params.append('callback')
7130        all_params.append('_return_http_data_only')
7131        all_params.append('_preload_content')
7132        all_params.append('_request_timeout')
7133
7134        params = locals()
7135        for key, val in iteritems(params['kwargs']):
7136            if key not in all_params:
7137                raise TypeError(
7138                    "Got an unexpected keyword argument '%s'"
7139                    " to method update_permission_profile" % key
7140                )
7141            params[key] = val
7142        del params['kwargs']
7143        # verify the required parameter 'account_id' is set
7144        if ('account_id' not in params) or (params['account_id'] is None):
7145            raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`")
7146        # verify the required parameter 'permission_profile_id' is set
7147        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
7148            raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`")
7149
7150
7151        collection_formats = {}
7152
7153        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
7154        path_params = {}
7155        if 'account_id' in params:
7156            path_params['accountId'] = params['account_id']
7157        if 'permission_profile_id' in params:
7158            path_params['permissionProfileId'] = params['permission_profile_id']
7159
7160        query_params = {}
7161        if 'include' in params:
7162            query_params['include'] = params['include']
7163
7164        header_params = {}
7165
7166        form_params = []
7167        local_var_files = {}
7168
7169        body_params = None
7170        if 'permission_profile' in params:
7171            body_params = params['permission_profile']
7172        # HTTP header `Accept`
7173        header_params['Accept'] = self.api_client.\
7174            select_header_accept(['application/json'])
7175
7176        # Authentication setting
7177        auth_settings = []
7178
7179        return self.api_client.call_api(resource_path, 'PUT',
7180                                        path_params,
7181                                        query_params,
7182                                        header_params,
7183                                        body=body_params,
7184                                        post_params=form_params,
7185                                        files=local_var_files,
7186                                        response_type='PermissionProfile',
7187                                        auth_settings=auth_settings,
7188                                        callback=params.get('callback'),
7189                                        _return_http_data_only=params.get('_return_http_data_only'),
7190                                        _preload_content=params.get('_preload_content', True),
7191                                        _request_timeout=params.get('_request_timeout'),
7192                                        collection_formats=collection_formats)
7193
7194    def update_settings(self, account_id, **kwargs):
7195        """
7196        Updates the account settings for an account.
7197        Updates the account settings for the specified account.
7198        This method makes a synchronous HTTP request by default. To make an
7199        asynchronous HTTP request, please define a `callback` function
7200        to be invoked when receiving the response.
7201        >>> def callback_function(response):
7202        >>>     pprint(response)
7203        >>>
7204        >>> thread = api.update_settings(account_id, callback=callback_function)
7205
7206        :param callback function: The callback function
7207            for asynchronous request. (optional)
7208        :param str account_id: The external account number (int) or account ID Guid. (required)
7209        :param AccountSettingsInformation account_settings_information:
7210        :return: None
7211                 If the method is called asynchronously,
7212                 returns the request thread.
7213        """
7214        kwargs['_return_http_data_only'] = True
7215        if kwargs.get('callback'):
7216            return self.update_settings_with_http_info(account_id, **kwargs)
7217        else:
7218            (data) = self.update_settings_with_http_info(account_id, **kwargs)
7219            return data
7220
7221    def update_settings_with_http_info(self, account_id, **kwargs):
7222        """
7223        Updates the account settings for an account.
7224        Updates the account settings for the specified account.
7225        This method makes a synchronous HTTP request by default. To make an
7226        asynchronous HTTP request, please define a `callback` function
7227        to be invoked when receiving the response.
7228        >>> def callback_function(response):
7229        >>>     pprint(response)
7230        >>>
7231        >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function)
7232
7233        :param callback function: The callback function
7234            for asynchronous request. (optional)
7235        :param str account_id: The external account number (int) or account ID Guid. (required)
7236        :param AccountSettingsInformation account_settings_information:
7237        :return: None
7238                 If the method is called asynchronously,
7239                 returns the request thread.
7240        """
7241
7242        all_params = ['account_id', 'account_settings_information']
7243        all_params.append('callback')
7244        all_params.append('_return_http_data_only')
7245        all_params.append('_preload_content')
7246        all_params.append('_request_timeout')
7247
7248        params = locals()
7249        for key, val in iteritems(params['kwargs']):
7250            if key not in all_params:
7251                raise TypeError(
7252                    "Got an unexpected keyword argument '%s'"
7253                    " to method update_settings" % key
7254                )
7255            params[key] = val
7256        del params['kwargs']
7257        # verify the required parameter 'account_id' is set
7258        if ('account_id' not in params) or (params['account_id'] is None):
7259            raise ValueError("Missing the required parameter `account_id` when calling `update_settings`")
7260
7261
7262        collection_formats = {}
7263
7264        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
7265        path_params = {}
7266        if 'account_id' in params:
7267            path_params['accountId'] = params['account_id']
7268
7269        query_params = {}
7270
7271        header_params = {}
7272
7273        form_params = []
7274        local_var_files = {}
7275
7276        body_params = None
7277        if 'account_settings_information' in params:
7278            body_params = params['account_settings_information']
7279        # HTTP header `Accept`
7280        header_params['Accept'] = self.api_client.\
7281            select_header_accept(['application/json'])
7282
7283        # Authentication setting
7284        auth_settings = []
7285
7286        return self.api_client.call_api(resource_path, 'PUT',
7287                                        path_params,
7288                                        query_params,
7289                                        header_params,
7290                                        body=body_params,
7291                                        post_params=form_params,
7292                                        files=local_var_files,
7293                                        response_type=None,
7294                                        auth_settings=auth_settings,
7295                                        callback=params.get('callback'),
7296                                        _return_http_data_only=params.get('_return_http_data_only'),
7297                                        _preload_content=params.get('_preload_content', True),
7298                                        _request_timeout=params.get('_request_timeout'),
7299                                        collection_formats=collection_formats)
7300
7301    def update_shared_access(self, account_id, **kwargs):
7302        """
7303        Reserved: Sets the shared access information for users.
7304        Reserved: Sets the shared access information for one or more users.
7305        This method makes a synchronous HTTP request by default. To make an
7306        asynchronous HTTP request, please define a `callback` function
7307        to be invoked when receiving the response.
7308        >>> def callback_function(response):
7309        >>>     pprint(response)
7310        >>>
7311        >>> thread = api.update_shared_access(account_id, callback=callback_function)
7312
7313        :param callback function: The callback function
7314            for asynchronous request. (optional)
7315        :param str account_id: The external account number (int) or account ID Guid. (required)
7316        :param str item_type:
7317        :param str preserve_existing_shared_access:
7318        :param str user_ids:
7319        :param AccountSharedAccess account_shared_access:
7320        :return: AccountSharedAccess
7321                 If the method is called asynchronously,
7322                 returns the request thread.
7323        """
7324        kwargs['_return_http_data_only'] = True
7325        if kwargs.get('callback'):
7326            return self.update_shared_access_with_http_info(account_id, **kwargs)
7327        else:
7328            (data) = self.update_shared_access_with_http_info(account_id, **kwargs)
7329            return data
7330
7331    def update_shared_access_with_http_info(self, account_id, **kwargs):
7332        """
7333        Reserved: Sets the shared access information for users.
7334        Reserved: Sets the shared access information for one or more users.
7335        This method makes a synchronous HTTP request by default. To make an
7336        asynchronous HTTP request, please define a `callback` function
7337        to be invoked when receiving the response.
7338        >>> def callback_function(response):
7339        >>>     pprint(response)
7340        >>>
7341        >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function)
7342
7343        :param callback function: The callback function
7344            for asynchronous request. (optional)
7345        :param str account_id: The external account number (int) or account ID Guid. (required)
7346        :param str item_type:
7347        :param str preserve_existing_shared_access:
7348        :param str user_ids:
7349        :param AccountSharedAccess account_shared_access:
7350        :return: AccountSharedAccess
7351                 If the method is called asynchronously,
7352                 returns the request thread.
7353        """
7354
7355        all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access']
7356        all_params.append('callback')
7357        all_params.append('_return_http_data_only')
7358        all_params.append('_preload_content')
7359        all_params.append('_request_timeout')
7360
7361        params = locals()
7362        for key, val in iteritems(params['kwargs']):
7363            if key not in all_params:
7364                raise TypeError(
7365                    "Got an unexpected keyword argument '%s'"
7366                    " to method update_shared_access" % key
7367                )
7368            params[key] = val
7369        del params['kwargs']
7370        # verify the required parameter 'account_id' is set
7371        if ('account_id' not in params) or (params['account_id'] is None):
7372            raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`")
7373
7374
7375        collection_formats = {}
7376
7377        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
7378        path_params = {}
7379        if 'account_id' in params:
7380            path_params['accountId'] = params['account_id']
7381
7382        query_params = {}
7383        if 'item_type' in params:
7384            query_params['item_type'] = params['item_type']
7385        if 'preserve_existing_shared_access' in params:
7386            query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access']
7387        if 'user_ids' in params:
7388            query_params['user_ids'] = params['user_ids']
7389
7390        header_params = {}
7391
7392        form_params = []
7393        local_var_files = {}
7394
7395        body_params = None
7396        if 'account_shared_access' in params:
7397            body_params = params['account_shared_access']
7398        # HTTP header `Accept`
7399        header_params['Accept'] = self.api_client.\
7400            select_header_accept(['application/json'])
7401
7402        # Authentication setting
7403        auth_settings = []
7404
7405        return self.api_client.call_api(resource_path, 'PUT',
7406                                        path_params,
7407                                        query_params,
7408                                        header_params,
7409                                        body=body_params,
7410                                        post_params=form_params,
7411                                        files=local_var_files,
7412                                        response_type='AccountSharedAccess',
7413                                        auth_settings=auth_settings,
7414                                        callback=params.get('callback'),
7415                                        _return_http_data_only=params.get('_return_http_data_only'),
7416                                        _preload_content=params.get('_preload_content', True),
7417                                        _request_timeout=params.get('_request_timeout'),
7418                                        collection_formats=collection_formats)
7419
7420    def update_watermark(self, account_id, **kwargs):
7421        """
7422        Update watermark information.
7423        
7424        This method makes a synchronous HTTP request by default. To make an
7425        asynchronous HTTP request, please define a `callback` function
7426        to be invoked when receiving the response.
7427        >>> def callback_function(response):
7428        >>>     pprint(response)
7429        >>>
7430        >>> thread = api.update_watermark(account_id, callback=callback_function)
7431
7432        :param callback function: The callback function
7433            for asynchronous request. (optional)
7434        :param str account_id: The external account number (int) or account ID Guid. (required)
7435        :param Watermark watermark:
7436        :return: Watermark
7437                 If the method is called asynchronously,
7438                 returns the request thread.
7439        """
7440        kwargs['_return_http_data_only'] = True
7441        if kwargs.get('callback'):
7442            return self.update_watermark_with_http_info(account_id, **kwargs)
7443        else:
7444            (data) = self.update_watermark_with_http_info(account_id, **kwargs)
7445            return data
7446
7447    def update_watermark_with_http_info(self, account_id, **kwargs):
7448        """
7449        Update watermark information.
7450        
7451        This method makes a synchronous HTTP request by default. To make an
7452        asynchronous HTTP request, please define a `callback` function
7453        to be invoked when receiving the response.
7454        >>> def callback_function(response):
7455        >>>     pprint(response)
7456        >>>
7457        >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function)
7458
7459        :param callback function: The callback function
7460            for asynchronous request. (optional)
7461        :param str account_id: The external account number (int) or account ID Guid. (required)
7462        :param Watermark watermark:
7463        :return: Watermark
7464                 If the method is called asynchronously,
7465                 returns the request thread.
7466        """
7467
7468        all_params = ['account_id', 'watermark']
7469        all_params.append('callback')
7470        all_params.append('_return_http_data_only')
7471        all_params.append('_preload_content')
7472        all_params.append('_request_timeout')
7473
7474        params = locals()
7475        for key, val in iteritems(params['kwargs']):
7476            if key not in all_params:
7477                raise TypeError(
7478                    "Got an unexpected keyword argument '%s'"
7479                    " to method update_watermark" % key
7480                )
7481            params[key] = val
7482        del params['kwargs']
7483        # verify the required parameter 'account_id' is set
7484        if ('account_id' not in params) or (params['account_id'] is None):
7485            raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`")
7486
7487
7488        collection_formats = {}
7489
7490        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
7491        path_params = {}
7492        if 'account_id' in params:
7493            path_params['accountId'] = params['account_id']
7494
7495        query_params = {}
7496
7497        header_params = {}
7498
7499        form_params = []
7500        local_var_files = {}
7501
7502        body_params = None
7503        if 'watermark' in params:
7504            body_params = params['watermark']
7505        # HTTP header `Accept`
7506        header_params['Accept'] = self.api_client.\
7507            select_header_accept(['application/json'])
7508
7509        # Authentication setting
7510        auth_settings = []
7511
7512        return self.api_client.call_api(resource_path, 'PUT',
7513                                        path_params,
7514                                        query_params,
7515                                        header_params,
7516                                        body=body_params,
7517                                        post_params=form_params,
7518                                        files=local_var_files,
7519                                        response_type='Watermark',
7520                                        auth_settings=auth_settings,
7521                                        callback=params.get('callback'),
7522                                        _return_http_data_only=params.get('_return_http_data_only'),
7523                                        _preload_content=params.get('_preload_content', True),
7524                                        _request_timeout=params.get('_request_timeout'),
7525                                        collection_formats=collection_formats)

NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen

AccountsApi(api_client=None)
35    def __init__(self, api_client=None):
36        config = Configuration()
37        if api_client:
38            self.api_client = api_client
39        else:
40            if not config.api_client:
41                config.api_client = ApiClient()
42            self.api_client = config.api_client
def create(self, **kwargs)
44    def create(self, **kwargs):
45        """
46        Creates new accounts.
47        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
48        This method makes a synchronous HTTP request by default. To make an
49        asynchronous HTTP request, please define a `callback` function
50        to be invoked when receiving the response.
51        >>> def callback_function(response):
52        >>>     pprint(response)
53        >>>
54        >>> thread = api.create(callback=callback_function)
55
56        :param callback function: The callback function
57            for asynchronous request. (optional)
58        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
59        :param NewAccountDefinition new_account_definition:
60        :return: NewAccountSummary
61                 If the method is called asynchronously,
62                 returns the request thread.
63        """
64        kwargs['_return_http_data_only'] = True
65        if kwargs.get('callback'):
66            return self.create_with_http_info(**kwargs)
67        else:
68            (data) = self.create_with_http_info(**kwargs)
69            return data

Creates new accounts. Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str preview_billing_plan: When set to true, creates the account using a preview billing plan.
  • NewAccountDefinition new_account_definition:
Returns

NewAccountSummary If the method is called asynchronously, returns the request thread.

def create_with_http_info(self, **kwargs)
 71    def create_with_http_info(self, **kwargs):
 72        """
 73        Creates new accounts.
 74        Creates new DocuSign service accounts.  This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a  [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time.  Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response  The response returns the new account ID, password and the default user information for each newly created account.  A 201 code is returned if the call succeeded.  While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account,  an `errorDetails` node is added in the response to each specific request that failed.
 75        This method makes a synchronous HTTP request by default. To make an
 76        asynchronous HTTP request, please define a `callback` function
 77        to be invoked when receiving the response.
 78        >>> def callback_function(response):
 79        >>>     pprint(response)
 80        >>>
 81        >>> thread = api.create_with_http_info(callback=callback_function)
 82
 83        :param callback function: The callback function
 84            for asynchronous request. (optional)
 85        :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan.
 86        :param NewAccountDefinition new_account_definition:
 87        :return: NewAccountSummary
 88                 If the method is called asynchronously,
 89                 returns the request thread.
 90        """
 91
 92        all_params = ['preview_billing_plan', 'new_account_definition']
 93        all_params.append('callback')
 94        all_params.append('_return_http_data_only')
 95        all_params.append('_preload_content')
 96        all_params.append('_request_timeout')
 97
 98        params = locals()
 99        for key, val in iteritems(params['kwargs']):
100            if key not in all_params:
101                raise TypeError(
102                    "Got an unexpected keyword argument '%s'"
103                    " to method create" % key
104                )
105            params[key] = val
106        del params['kwargs']
107
108
109        collection_formats = {}
110
111        resource_path = '/v2.1/accounts'.replace('{format}', 'json')
112        path_params = {}
113
114        query_params = {}
115        if 'preview_billing_plan' in params:
116            query_params['preview_billing_plan'] = params['preview_billing_plan']
117
118        header_params = {}
119
120        form_params = []
121        local_var_files = {}
122
123        body_params = None
124        if 'new_account_definition' in params:
125            body_params = params['new_account_definition']
126        # HTTP header `Accept`
127        header_params['Accept'] = self.api_client.\
128            select_header_accept(['application/json'])
129
130        # Authentication setting
131        auth_settings = []
132
133        return self.api_client.call_api(resource_path, 'POST',
134                                        path_params,
135                                        query_params,
136                                        header_params,
137                                        body=body_params,
138                                        post_params=form_params,
139                                        files=local_var_files,
140                                        response_type='NewAccountSummary',
141                                        auth_settings=auth_settings,
142                                        callback=params.get('callback'),
143                                        _return_http_data_only=params.get('_return_http_data_only'),
144                                        _preload_content=params.get('_preload_content', True),
145                                        _request_timeout=params.get('_request_timeout'),
146                                        collection_formats=collection_formats)

Creates new accounts. Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_with_http_info(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str preview_billing_plan: When set to true, creates the account using a preview billing plan.
  • NewAccountDefinition new_account_definition:
Returns

NewAccountSummary If the method is called asynchronously, returns the request thread.

def create_account_signatures(self, account_id, **kwargs)
148    def create_account_signatures(self, account_id, **kwargs):
149        """
150        Adds/updates one or more account signatures. This request may include images in multi-part format.
151        
152        This method makes a synchronous HTTP request by default. To make an
153        asynchronous HTTP request, please define a `callback` function
154        to be invoked when receiving the response.
155        >>> def callback_function(response):
156        >>>     pprint(response)
157        >>>
158        >>> thread = api.create_account_signatures(account_id, callback=callback_function)
159
160        :param callback function: The callback function
161            for asynchronous request. (optional)
162        :param str account_id: The external account number (int) or account ID Guid. (required)
163        :param str decode_only:
164        :param AccountSignaturesInformation account_signatures_information:
165        :return: AccountSignaturesInformation
166                 If the method is called asynchronously,
167                 returns the request thread.
168        """
169        kwargs['_return_http_data_only'] = True
170        if kwargs.get('callback'):
171            return self.create_account_signatures_with_http_info(account_id, **kwargs)
172        else:
173            (data) = self.create_account_signatures_with_http_info(account_id, **kwargs)
174            return data

Adds/updates one or more account signatures. This request may include images in multi-part format.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_account_signatures(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str decode_only:
  • AccountSignaturesInformation account_signatures_information:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def create_account_signatures_with_http_info(self, account_id, **kwargs)
176    def create_account_signatures_with_http_info(self, account_id, **kwargs):
177        """
178        Adds/updates one or more account signatures. This request may include images in multi-part format.
179        
180        This method makes a synchronous HTTP request by default. To make an
181        asynchronous HTTP request, please define a `callback` function
182        to be invoked when receiving the response.
183        >>> def callback_function(response):
184        >>>     pprint(response)
185        >>>
186        >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function)
187
188        :param callback function: The callback function
189            for asynchronous request. (optional)
190        :param str account_id: The external account number (int) or account ID Guid. (required)
191        :param str decode_only:
192        :param AccountSignaturesInformation account_signatures_information:
193        :return: AccountSignaturesInformation
194                 If the method is called asynchronously,
195                 returns the request thread.
196        """
197
198        all_params = ['account_id', 'decode_only', 'account_signatures_information']
199        all_params.append('callback')
200        all_params.append('_return_http_data_only')
201        all_params.append('_preload_content')
202        all_params.append('_request_timeout')
203
204        params = locals()
205        for key, val in iteritems(params['kwargs']):
206            if key not in all_params:
207                raise TypeError(
208                    "Got an unexpected keyword argument '%s'"
209                    " to method create_account_signatures" % key
210                )
211            params[key] = val
212        del params['kwargs']
213        # verify the required parameter 'account_id' is set
214        if ('account_id' not in params) or (params['account_id'] is None):
215            raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`")
216
217
218        collection_formats = {}
219
220        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
221        path_params = {}
222        if 'account_id' in params:
223            path_params['accountId'] = params['account_id']
224
225        query_params = {}
226        if 'decode_only' in params:
227            query_params['decode_only'] = params['decode_only']
228
229        header_params = {}
230
231        form_params = []
232        local_var_files = {}
233
234        body_params = None
235        if 'account_signatures_information' in params:
236            body_params = params['account_signatures_information']
237        # HTTP header `Accept`
238        header_params['Accept'] = self.api_client.\
239            select_header_accept(['application/json'])
240
241        # Authentication setting
242        auth_settings = []
243
244        return self.api_client.call_api(resource_path, 'POST',
245                                        path_params,
246                                        query_params,
247                                        header_params,
248                                        body=body_params,
249                                        post_params=form_params,
250                                        files=local_var_files,
251                                        response_type='AccountSignaturesInformation',
252                                        auth_settings=auth_settings,
253                                        callback=params.get('callback'),
254                                        _return_http_data_only=params.get('_return_http_data_only'),
255                                        _preload_content=params.get('_preload_content', True),
256                                        _request_timeout=params.get('_request_timeout'),
257                                        collection_formats=collection_formats)

Adds/updates one or more account signatures. This request may include images in multi-part format.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str decode_only:
  • AccountSignaturesInformation account_signatures_information:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def create_brand(self, account_id, **kwargs)
259    def create_brand(self, account_id, **kwargs):
260        """
261        Creates one or more brand profile files for the account.
262        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
263        This method makes a synchronous HTTP request by default. To make an
264        asynchronous HTTP request, please define a `callback` function
265        to be invoked when receiving the response.
266        >>> def callback_function(response):
267        >>>     pprint(response)
268        >>>
269        >>> thread = api.create_brand(account_id, callback=callback_function)
270
271        :param callback function: The callback function
272            for asynchronous request. (optional)
273        :param str account_id: The external account number (int) or account ID GUID. (required)
274        :param Brand brand: 
275        :return: BrandsResponse
276                 If the method is called asynchronously,
277                 returns the request thread.
278        """
279        kwargs['_return_http_data_only'] = True
280        if kwargs.get('callback'):
281            return self.create_brand_with_http_info(account_id, **kwargs)
282        else:
283            (data) = self.create_brand_with_http_info(account_id, **kwargs)
284            return data

Creates one or more brand profile files for the account. Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_brand(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • Brand brand:
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def create_brand_with_http_info(self, account_id, **kwargs)
286    def create_brand_with_http_info(self, account_id, **kwargs):
287        """
288        Creates one or more brand profile files for the account.
289        Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call.  An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version.  When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`.
290        This method makes a synchronous HTTP request by default. To make an
291        asynchronous HTTP request, please define a `callback` function
292        to be invoked when receiving the response.
293        >>> def callback_function(response):
294        >>>     pprint(response)
295        >>>
296        >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function)
297
298        :param callback function: The callback function
299            for asynchronous request. (optional)
300        :param str account_id: The external account number (int) or account ID GUID. (required)
301        :param Brand brand: 
302        :return: BrandsResponse
303                 If the method is called asynchronously,
304                 returns the request thread.
305        """
306
307        all_params = ['account_id', 'brand']
308        all_params.append('callback')
309        all_params.append('_return_http_data_only')
310        all_params.append('_preload_content')
311        all_params.append('_request_timeout')
312
313        params = locals()
314        for key, val in iteritems(params['kwargs']):
315            if key not in all_params:
316                raise TypeError(
317                    "Got an unexpected keyword argument '%s'"
318                    " to method create_brand" % key
319                )
320            params[key] = val
321        del params['kwargs']
322        # verify the required parameter 'account_id' is set
323        if ('account_id' not in params) or (params['account_id'] is None):
324            raise ValueError("Missing the required parameter `account_id` when calling `create_brand`")
325
326
327        collection_formats = {}
328
329        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
330        path_params = {}
331        if 'account_id' in params:
332            path_params['accountId'] = params['account_id']
333
334        query_params = {}
335
336        header_params = {}
337
338        form_params = []
339        local_var_files = {}
340
341        body_params = None
342        if 'brand' in params:
343            body_params = params['brand']
344        # HTTP header `Accept`
345        header_params['Accept'] = self.api_client.\
346            select_header_accept(['application/json'])
347
348        # Authentication setting
349        auth_settings = []
350
351        return self.api_client.call_api(resource_path, 'POST',
352                                        path_params,
353                                        query_params,
354                                        header_params,
355                                        body=body_params,
356                                        post_params=form_params,
357                                        files=local_var_files,
358                                        response_type='BrandsResponse',
359                                        auth_settings=auth_settings,
360                                        callback=params.get('callback'),
361                                        _return_http_data_only=params.get('_return_http_data_only'),
362                                        _preload_content=params.get('_preload_content', True),
363                                        _request_timeout=params.get('_request_timeout'),
364                                        collection_formats=collection_formats)

Creates one or more brand profile files for the account. Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_brand_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • Brand brand:
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def create_custom_field(self, account_id, **kwargs)
366    def create_custom_field(self, account_id, **kwargs):
367        """
368        Creates an acount custom field.
369        This method creates a custom field and makes it available for all new envelopes associated with an account.
370        This method makes a synchronous HTTP request by default. To make an
371        asynchronous HTTP request, please define a `callback` function
372        to be invoked when receiving the response.
373        >>> def callback_function(response):
374        >>>     pprint(response)
375        >>>
376        >>> thread = api.create_custom_field(account_id, callback=callback_function)
377
378        :param callback function: The callback function
379            for asynchronous request. (optional)
380        :param str account_id: The external account number (int) or account ID Guid. (required)
381        :param str apply_to_templates:
382        :param CustomField custom_field:
383        :return: CustomFields
384                 If the method is called asynchronously,
385                 returns the request thread.
386        """
387        kwargs['_return_http_data_only'] = True
388        if kwargs.get('callback'):
389            return self.create_custom_field_with_http_info(account_id, **kwargs)
390        else:
391            (data) = self.create_custom_field_with_http_info(account_id, **kwargs)
392            return data

Creates an acount custom field. This method creates a custom field and makes it available for all new envelopes associated with an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_custom_field(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str apply_to_templates:
  • CustomField custom_field:
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def create_custom_field_with_http_info(self, account_id, **kwargs)
394    def create_custom_field_with_http_info(self, account_id, **kwargs):
395        """
396        Creates an acount custom field.
397        This method creates a custom field and makes it available for all new envelopes associated with an account.
398        This method makes a synchronous HTTP request by default. To make an
399        asynchronous HTTP request, please define a `callback` function
400        to be invoked when receiving the response.
401        >>> def callback_function(response):
402        >>>     pprint(response)
403        >>>
404        >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function)
405
406        :param callback function: The callback function
407            for asynchronous request. (optional)
408        :param str account_id: The external account number (int) or account ID Guid. (required)
409        :param str apply_to_templates:
410        :param CustomField custom_field:
411        :return: CustomFields
412                 If the method is called asynchronously,
413                 returns the request thread.
414        """
415
416        all_params = ['account_id', 'apply_to_templates', 'custom_field']
417        all_params.append('callback')
418        all_params.append('_return_http_data_only')
419        all_params.append('_preload_content')
420        all_params.append('_request_timeout')
421
422        params = locals()
423        for key, val in iteritems(params['kwargs']):
424            if key not in all_params:
425                raise TypeError(
426                    "Got an unexpected keyword argument '%s'"
427                    " to method create_custom_field" % key
428                )
429            params[key] = val
430        del params['kwargs']
431        # verify the required parameter 'account_id' is set
432        if ('account_id' not in params) or (params['account_id'] is None):
433            raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`")
434
435
436        collection_formats = {}
437
438        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
439        path_params = {}
440        if 'account_id' in params:
441            path_params['accountId'] = params['account_id']
442
443        query_params = {}
444        if 'apply_to_templates' in params:
445            query_params['apply_to_templates'] = params['apply_to_templates']
446
447        header_params = {}
448
449        form_params = []
450        local_var_files = {}
451
452        body_params = None
453        if 'custom_field' in params:
454            body_params = params['custom_field']
455        # HTTP header `Accept`
456        header_params['Accept'] = self.api_client.\
457            select_header_accept(['application/json'])
458
459        # Authentication setting
460        auth_settings = []
461
462        return self.api_client.call_api(resource_path, 'POST',
463                                        path_params,
464                                        query_params,
465                                        header_params,
466                                        body=body_params,
467                                        post_params=form_params,
468                                        files=local_var_files,
469                                        response_type='CustomFields',
470                                        auth_settings=auth_settings,
471                                        callback=params.get('callback'),
472                                        _return_http_data_only=params.get('_return_http_data_only'),
473                                        _preload_content=params.get('_preload_content', True),
474                                        _request_timeout=params.get('_request_timeout'),
475                                        collection_formats=collection_formats)

Creates an acount custom field. This method creates a custom field and makes it available for all new envelopes associated with an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str apply_to_templates:
  • CustomField custom_field:
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def create_permission_profile(self, account_id, **kwargs)
477    def create_permission_profile(self, account_id, **kwargs):
478        """
479        Creates a new permission profile in the specified account.
480        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
481        This method makes a synchronous HTTP request by default. To make an
482        asynchronous HTTP request, please define a `callback` function
483        to be invoked when receiving the response.
484        >>> def callback_function(response):
485        >>>     pprint(response)
486        >>>
487        >>> thread = api.create_permission_profile(account_id, callback=callback_function)
488
489        :param callback function: The callback function
490            for asynchronous request. (optional)
491        :param str account_id: The external account number (int) or account ID Guid. (required)
492        :param str include:
493        :param PermissionProfile permission_profile:
494        :return: PermissionProfile
495                 If the method is called asynchronously,
496                 returns the request thread.
497        """
498        kwargs['_return_http_data_only'] = True
499        if kwargs.get('callback'):
500            return self.create_permission_profile_with_http_info(account_id, **kwargs)
501        else:
502            (data) = self.create_permission_profile_with_http_info(account_id, **kwargs)
503            return data

Creates a new permission profile in the specified account. This method creates a new permission profile for an account. ### Related topics - How to create a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_permission_profile(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include:
  • PermissionProfile permission_profile:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def create_permission_profile_with_http_info(self, account_id, **kwargs)
505    def create_permission_profile_with_http_info(self, account_id, **kwargs):
506        """
507        Creates a new permission profile in the specified account.
508        This method creates a new permission profile for an account.  ### Related topics  - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 
509        This method makes a synchronous HTTP request by default. To make an
510        asynchronous HTTP request, please define a `callback` function
511        to be invoked when receiving the response.
512        >>> def callback_function(response):
513        >>>     pprint(response)
514        >>>
515        >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function)
516
517        :param callback function: The callback function
518            for asynchronous request. (optional)
519        :param str account_id: The external account number (int) or account ID Guid. (required)
520        :param str include:
521        :param PermissionProfile permission_profile:
522        :return: PermissionProfile
523                 If the method is called asynchronously,
524                 returns the request thread.
525        """
526
527        all_params = ['account_id', 'include', 'permission_profile']
528        all_params.append('callback')
529        all_params.append('_return_http_data_only')
530        all_params.append('_preload_content')
531        all_params.append('_request_timeout')
532
533        params = locals()
534        for key, val in iteritems(params['kwargs']):
535            if key not in all_params:
536                raise TypeError(
537                    "Got an unexpected keyword argument '%s'"
538                    " to method create_permission_profile" % key
539                )
540            params[key] = val
541        del params['kwargs']
542        # verify the required parameter 'account_id' is set
543        if ('account_id' not in params) or (params['account_id'] is None):
544            raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`")
545
546
547        collection_formats = {}
548
549        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
550        path_params = {}
551        if 'account_id' in params:
552            path_params['accountId'] = params['account_id']
553
554        query_params = {}
555        if 'include' in params:
556            query_params['include'] = params['include']
557
558        header_params = {}
559
560        form_params = []
561        local_var_files = {}
562
563        body_params = None
564        if 'permission_profile' in params:
565            body_params = params['permission_profile']
566        # HTTP header `Accept`
567        header_params['Accept'] = self.api_client.\
568            select_header_accept(['application/json'])
569
570        # Authentication setting
571        auth_settings = []
572
573        return self.api_client.call_api(resource_path, 'POST',
574                                        path_params,
575                                        query_params,
576                                        header_params,
577                                        body=body_params,
578                                        post_params=form_params,
579                                        files=local_var_files,
580                                        response_type='PermissionProfile',
581                                        auth_settings=auth_settings,
582                                        callback=params.get('callback'),
583                                        _return_http_data_only=params.get('_return_http_data_only'),
584                                        _preload_content=params.get('_preload_content', True),
585                                        _request_timeout=params.get('_request_timeout'),
586                                        collection_formats=collection_formats)

Creates a new permission profile in the specified account. This method creates a new permission profile for an account. ### Related topics - How to create a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include:
  • PermissionProfile permission_profile:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def delete(self, account_id, **kwargs)
588    def delete(self, account_id, **kwargs):
589        """
590        Deletes the specified account.
591        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
592        This method makes a synchronous HTTP request by default. To make an
593        asynchronous HTTP request, please define a `callback` function
594        to be invoked when receiving the response.
595        >>> def callback_function(response):
596        >>>     pprint(response)
597        >>>
598        >>> thread = api.delete(account_id, callback=callback_function)
599
600        :param callback function: The callback function
601            for asynchronous request. (optional)
602        :param str account_id: The external account number (int) or account ID Guid. (required)
603        :return: None
604                 If the method is called asynchronously,
605                 returns the request thread.
606        """
607        kwargs['_return_http_data_only'] = True
608        if kwargs.get('callback'):
609            return self.delete_with_http_info(account_id, **kwargs)
610        else:
611            (data) = self.delete_with_http_info(account_id, **kwargs)
612            return data

Deletes the specified account. This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_with_http_info(self, account_id, **kwargs)
614    def delete_with_http_info(self, account_id, **kwargs):
615        """
616        Deletes the specified account.
617        This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
618        This method makes a synchronous HTTP request by default. To make an
619        asynchronous HTTP request, please define a `callback` function
620        to be invoked when receiving the response.
621        >>> def callback_function(response):
622        >>>     pprint(response)
623        >>>
624        >>> thread = api.delete_with_http_info(account_id, callback=callback_function)
625
626        :param callback function: The callback function
627            for asynchronous request. (optional)
628        :param str account_id: The external account number (int) or account ID Guid. (required)
629        :return: None
630                 If the method is called asynchronously,
631                 returns the request thread.
632        """
633
634        all_params = ['account_id']
635        all_params.append('callback')
636        all_params.append('_return_http_data_only')
637        all_params.append('_preload_content')
638        all_params.append('_request_timeout')
639
640        params = locals()
641        for key, val in iteritems(params['kwargs']):
642            if key not in all_params:
643                raise TypeError(
644                    "Got an unexpected keyword argument '%s'"
645                    " to method delete" % key
646                )
647            params[key] = val
648        del params['kwargs']
649        # verify the required parameter 'account_id' is set
650        if ('account_id' not in params) or (params['account_id'] is None):
651            raise ValueError("Missing the required parameter `account_id` when calling `delete`")
652
653
654        collection_formats = {}
655
656        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
657        path_params = {}
658        if 'account_id' in params:
659            path_params['accountId'] = params['account_id']
660
661        query_params = {}
662
663        header_params = {}
664
665        form_params = []
666        local_var_files = {}
667
668        body_params = None
669        # HTTP header `Accept`
670        header_params['Accept'] = self.api_client.\
671            select_header_accept(['application/json'])
672
673        # Authentication setting
674        auth_settings = []
675
676        return self.api_client.call_api(resource_path, 'DELETE',
677                                        path_params,
678                                        query_params,
679                                        header_params,
680                                        body=body_params,
681                                        post_params=form_params,
682                                        files=local_var_files,
683                                        response_type=None,
684                                        auth_settings=auth_settings,
685                                        callback=params.get('callback'),
686                                        _return_http_data_only=params.get('_return_http_data_only'),
687                                        _preload_content=params.get('_preload_content', True),
688                                        _request_timeout=params.get('_request_timeout'),
689                                        collection_formats=collection_formats)

Deletes the specified account. This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_account_signature(self, account_id, signature_id, **kwargs)
691    def delete_account_signature(self, account_id, signature_id, **kwargs):
692        """
693        Close the specified signature by Id.
694        
695        This method makes a synchronous HTTP request by default. To make an
696        asynchronous HTTP request, please define a `callback` function
697        to be invoked when receiving the response.
698        >>> def callback_function(response):
699        >>>     pprint(response)
700        >>>
701        >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function)
702
703        :param callback function: The callback function
704            for asynchronous request. (optional)
705        :param str account_id: The external account number (int) or account ID Guid. (required)
706        :param str signature_id: The ID of the signature being accessed. (required)
707        :return: None
708                 If the method is called asynchronously,
709                 returns the request thread.
710        """
711        kwargs['_return_http_data_only'] = True
712        if kwargs.get('callback'):
713            return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
714        else:
715            (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs)
716            return data

Close the specified signature by Id.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
718    def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
719        """
720        Close the specified signature by Id.
721        
722        This method makes a synchronous HTTP request by default. To make an
723        asynchronous HTTP request, please define a `callback` function
724        to be invoked when receiving the response.
725        >>> def callback_function(response):
726        >>>     pprint(response)
727        >>>
728        >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
729
730        :param callback function: The callback function
731            for asynchronous request. (optional)
732        :param str account_id: The external account number (int) or account ID Guid. (required)
733        :param str signature_id: The ID of the signature being accessed. (required)
734        :return: None
735                 If the method is called asynchronously,
736                 returns the request thread.
737        """
738
739        all_params = ['account_id', 'signature_id']
740        all_params.append('callback')
741        all_params.append('_return_http_data_only')
742        all_params.append('_preload_content')
743        all_params.append('_request_timeout')
744
745        params = locals()
746        for key, val in iteritems(params['kwargs']):
747            if key not in all_params:
748                raise TypeError(
749                    "Got an unexpected keyword argument '%s'"
750                    " to method delete_account_signature" % key
751                )
752            params[key] = val
753        del params['kwargs']
754        # verify the required parameter 'account_id' is set
755        if ('account_id' not in params) or (params['account_id'] is None):
756            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`")
757        # verify the required parameter 'signature_id' is set
758        if ('signature_id' not in params) or (params['signature_id'] is None):
759            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`")
760
761
762        collection_formats = {}
763
764        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
765        path_params = {}
766        if 'account_id' in params:
767            path_params['accountId'] = params['account_id']
768        if 'signature_id' in params:
769            path_params['signatureId'] = params['signature_id']
770
771        query_params = {}
772
773        header_params = {}
774
775        form_params = []
776        local_var_files = {}
777
778        body_params = None
779        # HTTP header `Accept`
780        header_params['Accept'] = self.api_client.\
781            select_header_accept(['application/json'])
782
783        # Authentication setting
784        auth_settings = []
785
786        return self.api_client.call_api(resource_path, 'DELETE',
787                                        path_params,
788                                        query_params,
789                                        header_params,
790                                        body=body_params,
791                                        post_params=form_params,
792                                        files=local_var_files,
793                                        response_type=None,
794                                        auth_settings=auth_settings,
795                                        callback=params.get('callback'),
796                                        _return_http_data_only=params.get('_return_http_data_only'),
797                                        _preload_content=params.get('_preload_content', True),
798                                        _request_timeout=params.get('_request_timeout'),
799                                        collection_formats=collection_formats)

Close the specified signature by Id.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
801    def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
802        """
803        Deletes a signature, initials, or stamps image.
804        
805        This method makes a synchronous HTTP request by default. To make an
806        asynchronous HTTP request, please define a `callback` function
807        to be invoked when receiving the response.
808        >>> def callback_function(response):
809        >>>     pprint(response)
810        >>>
811        >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
812
813        :param callback function: The callback function
814            for asynchronous request. (optional)
815        :param str account_id: The external account number (int) or account ID Guid. (required)
816        :param str image_type: One of **signature_image** or **initials_image**. (required)
817        :param str signature_id: The ID of the signature being accessed. (required)
818        :return: AccountSignature
819                 If the method is called asynchronously,
820                 returns the request thread.
821        """
822        kwargs['_return_http_data_only'] = True
823        if kwargs.get('callback'):
824            return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
825        else:
826            (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
827            return data

Deletes a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
829    def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
830        """
831        Deletes a signature, initials, or stamps image.
832        
833        This method makes a synchronous HTTP request by default. To make an
834        asynchronous HTTP request, please define a `callback` function
835        to be invoked when receiving the response.
836        >>> def callback_function(response):
837        >>>     pprint(response)
838        >>>
839        >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
840
841        :param callback function: The callback function
842            for asynchronous request. (optional)
843        :param str account_id: The external account number (int) or account ID Guid. (required)
844        :param str image_type: One of **signature_image** or **initials_image**. (required)
845        :param str signature_id: The ID of the signature being accessed. (required)
846        :return: AccountSignature
847                 If the method is called asynchronously,
848                 returns the request thread.
849        """
850
851        all_params = ['account_id', 'image_type', 'signature_id']
852        all_params.append('callback')
853        all_params.append('_return_http_data_only')
854        all_params.append('_preload_content')
855        all_params.append('_request_timeout')
856
857        params = locals()
858        for key, val in iteritems(params['kwargs']):
859            if key not in all_params:
860                raise TypeError(
861                    "Got an unexpected keyword argument '%s'"
862                    " to method delete_account_signature_image" % key
863                )
864            params[key] = val
865        del params['kwargs']
866        # verify the required parameter 'account_id' is set
867        if ('account_id' not in params) or (params['account_id'] is None):
868            raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`")
869        # verify the required parameter 'image_type' is set
870        if ('image_type' not in params) or (params['image_type'] is None):
871            raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`")
872        # verify the required parameter 'signature_id' is set
873        if ('signature_id' not in params) or (params['signature_id'] is None):
874            raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`")
875
876
877        collection_formats = {}
878
879        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
880        path_params = {}
881        if 'account_id' in params:
882            path_params['accountId'] = params['account_id']
883        if 'image_type' in params:
884            path_params['imageType'] = params['image_type']
885        if 'signature_id' in params:
886            path_params['signatureId'] = params['signature_id']
887
888        query_params = {}
889
890        header_params = {}
891
892        form_params = []
893        local_var_files = {}
894
895        body_params = None
896        # HTTP header `Accept`
897        header_params['Accept'] = self.api_client.\
898            select_header_accept(['application/json'])
899
900        # Authentication setting
901        auth_settings = []
902
903        return self.api_client.call_api(resource_path, 'DELETE',
904                                        path_params,
905                                        query_params,
906                                        header_params,
907                                        body=body_params,
908                                        post_params=form_params,
909                                        files=local_var_files,
910                                        response_type='AccountSignature',
911                                        auth_settings=auth_settings,
912                                        callback=params.get('callback'),
913                                        _return_http_data_only=params.get('_return_http_data_only'),
914                                        _preload_content=params.get('_preload_content', True),
915                                        _request_timeout=params.get('_request_timeout'),
916                                        collection_formats=collection_formats)

Deletes a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def delete_brand(self, account_id, brand_id, **kwargs)
918    def delete_brand(self, account_id, brand_id, **kwargs):
919        """
920        Removes a brand.
921        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
922        This method makes a synchronous HTTP request by default. To make an
923        asynchronous HTTP request, please define a `callback` function
924        to be invoked when receiving the response.
925        >>> def callback_function(response):
926        >>>     pprint(response)
927        >>>
928        >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function)
929
930        :param callback function: The callback function
931            for asynchronous request. (optional)
932        :param str account_id: The external account number (int) or account ID Guid. (required)
933        :param str brand_id: The unique identifier of a brand. (required)
934        :return: None
935                 If the method is called asynchronously,
936                 returns the request thread.
937        """
938        kwargs['_return_http_data_only'] = True
939        if kwargs.get('callback'):
940            return self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
941        else:
942            (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs)
943            return data

Removes a brand. This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brand(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_brand_with_http_info(self, account_id, brand_id, **kwargs)
 945    def delete_brand_with_http_info(self, account_id, brand_id, **kwargs):
 946        """
 947        Removes a brand.
 948        This method deletes a brand from an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
 949        This method makes a synchronous HTTP request by default. To make an
 950        asynchronous HTTP request, please define a `callback` function
 951        to be invoked when receiving the response.
 952        >>> def callback_function(response):
 953        >>>     pprint(response)
 954        >>>
 955        >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
 956
 957        :param callback function: The callback function
 958            for asynchronous request. (optional)
 959        :param str account_id: The external account number (int) or account ID Guid. (required)
 960        :param str brand_id: The unique identifier of a brand. (required)
 961        :return: None
 962                 If the method is called asynchronously,
 963                 returns the request thread.
 964        """
 965
 966        all_params = ['account_id', 'brand_id']
 967        all_params.append('callback')
 968        all_params.append('_return_http_data_only')
 969        all_params.append('_preload_content')
 970        all_params.append('_request_timeout')
 971
 972        params = locals()
 973        for key, val in iteritems(params['kwargs']):
 974            if key not in all_params:
 975                raise TypeError(
 976                    "Got an unexpected keyword argument '%s'"
 977                    " to method delete_brand" % key
 978                )
 979            params[key] = val
 980        del params['kwargs']
 981        # verify the required parameter 'account_id' is set
 982        if ('account_id' not in params) or (params['account_id'] is None):
 983            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`")
 984        # verify the required parameter 'brand_id' is set
 985        if ('brand_id' not in params) or (params['brand_id'] is None):
 986            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`")
 987
 988
 989        collection_formats = {}
 990
 991        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
 992        path_params = {}
 993        if 'account_id' in params:
 994            path_params['accountId'] = params['account_id']
 995        if 'brand_id' in params:
 996            path_params['brandId'] = params['brand_id']
 997
 998        query_params = {}
 999
1000        header_params = {}
1001
1002        form_params = []
1003        local_var_files = {}
1004
1005        body_params = None
1006        # HTTP header `Accept`
1007        header_params['Accept'] = self.api_client.\
1008            select_header_accept(['application/json'])
1009
1010        # Authentication setting
1011        auth_settings = []
1012
1013        return self.api_client.call_api(resource_path, 'DELETE',
1014                                        path_params,
1015                                        query_params,
1016                                        header_params,
1017                                        body=body_params,
1018                                        post_params=form_params,
1019                                        files=local_var_files,
1020                                        response_type=None,
1021                                        auth_settings=auth_settings,
1022                                        callback=params.get('callback'),
1023                                        _return_http_data_only=params.get('_return_http_data_only'),
1024                                        _preload_content=params.get('_preload_content', True),
1025                                        _request_timeout=params.get('_request_timeout'),
1026                                        collection_formats=collection_formats)

Removes a brand. This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
1028    def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
1029        """
1030        Delete one branding logo.
1031        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1032        This method makes a synchronous HTTP request by default. To make an
1033        asynchronous HTTP request, please define a `callback` function
1034        to be invoked when receiving the response.
1035        >>> def callback_function(response):
1036        >>>     pprint(response)
1037        >>>
1038        >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
1039
1040        :param callback function: The callback function
1041            for asynchronous request. (optional)
1042        :param str account_id: The external account number (int) or account ID Guid. (required)
1043        :param str brand_id: The unique identifier of a brand. (required)
1044        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1045        :return: None
1046                 If the method is called asynchronously,
1047                 returns the request thread.
1048        """
1049        kwargs['_return_http_data_only'] = True
1050        if kwargs.get('callback'):
1051            return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1052        else:
1053            (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
1054            return data

Delete one branding logo. This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str logo_type: One of Primary, Secondary or Email. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
1056    def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
1057        """
1058        Delete one branding logo.
1059        This method deletes a single logo from an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
1060        This method makes a synchronous HTTP request by default. To make an
1061        asynchronous HTTP request, please define a `callback` function
1062        to be invoked when receiving the response.
1063        >>> def callback_function(response):
1064        >>>     pprint(response)
1065        >>>
1066        >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
1067
1068        :param callback function: The callback function
1069            for asynchronous request. (optional)
1070        :param str account_id: The external account number (int) or account ID Guid. (required)
1071        :param str brand_id: The unique identifier of a brand. (required)
1072        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
1073        :return: None
1074                 If the method is called asynchronously,
1075                 returns the request thread.
1076        """
1077
1078        all_params = ['account_id', 'brand_id', 'logo_type']
1079        all_params.append('callback')
1080        all_params.append('_return_http_data_only')
1081        all_params.append('_preload_content')
1082        all_params.append('_request_timeout')
1083
1084        params = locals()
1085        for key, val in iteritems(params['kwargs']):
1086            if key not in all_params:
1087                raise TypeError(
1088                    "Got an unexpected keyword argument '%s'"
1089                    " to method delete_brand_logo_by_type" % key
1090                )
1091            params[key] = val
1092        del params['kwargs']
1093        # verify the required parameter 'account_id' is set
1094        if ('account_id' not in params) or (params['account_id'] is None):
1095            raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`")
1096        # verify the required parameter 'brand_id' is set
1097        if ('brand_id' not in params) or (params['brand_id'] is None):
1098            raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`")
1099        # verify the required parameter 'logo_type' is set
1100        if ('logo_type' not in params) or (params['logo_type'] is None):
1101            raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`")
1102
1103
1104        collection_formats = {}
1105
1106        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
1107        path_params = {}
1108        if 'account_id' in params:
1109            path_params['accountId'] = params['account_id']
1110        if 'brand_id' in params:
1111            path_params['brandId'] = params['brand_id']
1112        if 'logo_type' in params:
1113            path_params['logoType'] = params['logo_type']
1114
1115        query_params = {}
1116
1117        header_params = {}
1118
1119        form_params = []
1120        local_var_files = {}
1121
1122        body_params = None
1123        # HTTP header `Accept`
1124        header_params['Accept'] = self.api_client.\
1125            select_header_accept(['application/json'])
1126
1127        # Authentication setting
1128        auth_settings = []
1129
1130        return self.api_client.call_api(resource_path, 'DELETE',
1131                                        path_params,
1132                                        query_params,
1133                                        header_params,
1134                                        body=body_params,
1135                                        post_params=form_params,
1136                                        files=local_var_files,
1137                                        response_type=None,
1138                                        auth_settings=auth_settings,
1139                                        callback=params.get('callback'),
1140                                        _return_http_data_only=params.get('_return_http_data_only'),
1141                                        _preload_content=params.get('_preload_content', True),
1142                                        _request_timeout=params.get('_request_timeout'),
1143                                        collection_formats=collection_formats)

Delete one branding logo. This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str logo_type: One of Primary, Secondary or Email. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_brands(self, account_id, **kwargs)
1145    def delete_brands(self, account_id, **kwargs):
1146        """
1147        Deletes one or more brand profiles.
1148        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1149        This method makes a synchronous HTTP request by default. To make an
1150        asynchronous HTTP request, please define a `callback` function
1151        to be invoked when receiving the response.
1152        >>> def callback_function(response):
1153        >>>     pprint(response)
1154        >>>
1155        >>> thread = api.delete_brands(account_id, callback=callback_function)
1156
1157        :param callback function: The callback function
1158            for asynchronous request. (optional)
1159        :param str account_id: The external account number (int) or account ID Guid. (required)
1160        :param BrandsRequest brands_request:
1161        :return: BrandsResponse
1162                 If the method is called asynchronously,
1163                 returns the request thread.
1164        """
1165        kwargs['_return_http_data_only'] = True
1166        if kwargs.get('callback'):
1167            return self.delete_brands_with_http_info(account_id, **kwargs)
1168        else:
1169            (data) = self.delete_brands_with_http_info(account_id, **kwargs)
1170            return data

Deletes one or more brand profiles. Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brands(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • BrandsRequest brands_request:
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def delete_brands_with_http_info(self, account_id, **kwargs)
1172    def delete_brands_with_http_info(self, account_id, **kwargs):
1173        """
1174        Deletes one or more brand profiles.
1175        Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call.
1176        This method makes a synchronous HTTP request by default. To make an
1177        asynchronous HTTP request, please define a `callback` function
1178        to be invoked when receiving the response.
1179        >>> def callback_function(response):
1180        >>>     pprint(response)
1181        >>>
1182        >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function)
1183
1184        :param callback function: The callback function
1185            for asynchronous request. (optional)
1186        :param str account_id: The external account number (int) or account ID Guid. (required)
1187        :param BrandsRequest brands_request:
1188        :return: BrandsResponse
1189                 If the method is called asynchronously,
1190                 returns the request thread.
1191        """
1192
1193        all_params = ['account_id', 'brands_request']
1194        all_params.append('callback')
1195        all_params.append('_return_http_data_only')
1196        all_params.append('_preload_content')
1197        all_params.append('_request_timeout')
1198
1199        params = locals()
1200        for key, val in iteritems(params['kwargs']):
1201            if key not in all_params:
1202                raise TypeError(
1203                    "Got an unexpected keyword argument '%s'"
1204                    " to method delete_brands" % key
1205                )
1206            params[key] = val
1207        del params['kwargs']
1208        # verify the required parameter 'account_id' is set
1209        if ('account_id' not in params) or (params['account_id'] is None):
1210            raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`")
1211
1212
1213        collection_formats = {}
1214
1215        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
1216        path_params = {}
1217        if 'account_id' in params:
1218            path_params['accountId'] = params['account_id']
1219
1220        query_params = {}
1221
1222        header_params = {}
1223
1224        form_params = []
1225        local_var_files = {}
1226
1227        body_params = None
1228        if 'brands_request' in params:
1229            body_params = params['brands_request']
1230        # HTTP header `Accept`
1231        header_params['Accept'] = self.api_client.\
1232            select_header_accept(['application/json'])
1233
1234        # Authentication setting
1235        auth_settings = []
1236
1237        return self.api_client.call_api(resource_path, 'DELETE',
1238                                        path_params,
1239                                        query_params,
1240                                        header_params,
1241                                        body=body_params,
1242                                        post_params=form_params,
1243                                        files=local_var_files,
1244                                        response_type='BrandsResponse',
1245                                        auth_settings=auth_settings,
1246                                        callback=params.get('callback'),
1247                                        _return_http_data_only=params.get('_return_http_data_only'),
1248                                        _preload_content=params.get('_preload_content', True),
1249                                        _request_timeout=params.get('_request_timeout'),
1250                                        collection_formats=collection_formats)

Deletes one or more brand profiles. Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • BrandsRequest brands_request:
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def delete_captive_recipient(self, account_id, recipient_part, **kwargs)
1252    def delete_captive_recipient(self, account_id, recipient_part, **kwargs):
1253        """
1254        Deletes the signature for one or more captive recipient records.
1255        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1256        This method makes a synchronous HTTP request by default. To make an
1257        asynchronous HTTP request, please define a `callback` function
1258        to be invoked when receiving the response.
1259        >>> def callback_function(response):
1260        >>>     pprint(response)
1261        >>>
1262        >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function)
1263
1264        :param callback function: The callback function
1265            for asynchronous request. (optional)
1266        :param str account_id: The external account number (int) or account ID Guid. (required)
1267        :param str recipient_part: (required)
1268        :param CaptiveRecipientInformation captive_recipient_information:
1269        :return: CaptiveRecipientInformation
1270                 If the method is called asynchronously,
1271                 returns the request thread.
1272        """
1273        kwargs['_return_http_data_only'] = True
1274        if kwargs.get('callback'):
1275            return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1276        else:
1277            (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs)
1278            return data

Deletes the signature for one or more captive recipient records. Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str recipient_part: (required)
  • CaptiveRecipientInformation captive_recipient_information:
Returns

CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.

def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs)
1280    def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs):
1281        """
1282        Deletes the signature for one or more captive recipient records.
1283        Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
1284        This method makes a synchronous HTTP request by default. To make an
1285        asynchronous HTTP request, please define a `callback` function
1286        to be invoked when receiving the response.
1287        >>> def callback_function(response):
1288        >>>     pprint(response)
1289        >>>
1290        >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
1291
1292        :param callback function: The callback function
1293            for asynchronous request. (optional)
1294        :param str account_id: The external account number (int) or account ID Guid. (required)
1295        :param str recipient_part: (required)
1296        :param CaptiveRecipientInformation captive_recipient_information:
1297        :return: CaptiveRecipientInformation
1298                 If the method is called asynchronously,
1299                 returns the request thread.
1300        """
1301
1302        all_params = ['account_id', 'recipient_part', 'captive_recipient_information']
1303        all_params.append('callback')
1304        all_params.append('_return_http_data_only')
1305        all_params.append('_preload_content')
1306        all_params.append('_request_timeout')
1307
1308        params = locals()
1309        for key, val in iteritems(params['kwargs']):
1310            if key not in all_params:
1311                raise TypeError(
1312                    "Got an unexpected keyword argument '%s'"
1313                    " to method delete_captive_recipient" % key
1314                )
1315            params[key] = val
1316        del params['kwargs']
1317        # verify the required parameter 'account_id' is set
1318        if ('account_id' not in params) or (params['account_id'] is None):
1319            raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`")
1320        # verify the required parameter 'recipient_part' is set
1321        if ('recipient_part' not in params) or (params['recipient_part'] is None):
1322            raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`")
1323
1324
1325        collection_formats = {}
1326
1327        resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json')
1328        path_params = {}
1329        if 'account_id' in params:
1330            path_params['accountId'] = params['account_id']
1331        if 'recipient_part' in params:
1332            path_params['recipientPart'] = params['recipient_part']
1333
1334        query_params = {}
1335
1336        header_params = {}
1337
1338        form_params = []
1339        local_var_files = {}
1340
1341        body_params = None
1342        if 'captive_recipient_information' in params:
1343            body_params = params['captive_recipient_information']
1344        # HTTP header `Accept`
1345        header_params['Accept'] = self.api_client.\
1346            select_header_accept(['application/json'])
1347
1348        # Authentication setting
1349        auth_settings = []
1350
1351        return self.api_client.call_api(resource_path, 'DELETE',
1352                                        path_params,
1353                                        query_params,
1354                                        header_params,
1355                                        body=body_params,
1356                                        post_params=form_params,
1357                                        files=local_var_files,
1358                                        response_type='CaptiveRecipientInformation',
1359                                        auth_settings=auth_settings,
1360                                        callback=params.get('callback'),
1361                                        _return_http_data_only=params.get('_return_http_data_only'),
1362                                        _preload_content=params.get('_preload_content', True),
1363                                        _request_timeout=params.get('_request_timeout'),
1364                                        collection_formats=collection_formats)

Deletes the signature for one or more captive recipient records. Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str recipient_part: (required)
  • CaptiveRecipientInformation captive_recipient_information:
Returns

CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.

def delete_custom_field(self, account_id, custom_field_id, **kwargs)
1366    def delete_custom_field(self, account_id, custom_field_id, **kwargs):
1367        """
1368        Delete an existing account custom field.
1369        This method deletes an existing account custom field.
1370        This method makes a synchronous HTTP request by default. To make an
1371        asynchronous HTTP request, please define a `callback` function
1372        to be invoked when receiving the response.
1373        >>> def callback_function(response):
1374        >>>     pprint(response)
1375        >>>
1376        >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function)
1377
1378        :param callback function: The callback function
1379            for asynchronous request. (optional)
1380        :param str account_id: The external account number (int) or account ID Guid. (required)
1381        :param str custom_field_id: (required)
1382        :param str apply_to_templates:
1383        :return: None
1384                 If the method is called asynchronously,
1385                 returns the request thread.
1386        """
1387        kwargs['_return_http_data_only'] = True
1388        if kwargs.get('callback'):
1389            return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1390        else:
1391            (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
1392            return data

Delete an existing account custom field. This method deletes an existing account custom field. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str custom_field_id: (required)
  • str apply_to_templates:
Returns

None If the method is called asynchronously, returns the request thread.

def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
1394    def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
1395        """
1396        Delete an existing account custom field.
1397        This method deletes an existing account custom field.
1398        This method makes a synchronous HTTP request by default. To make an
1399        asynchronous HTTP request, please define a `callback` function
1400        to be invoked when receiving the response.
1401        >>> def callback_function(response):
1402        >>>     pprint(response)
1403        >>>
1404        >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
1405
1406        :param callback function: The callback function
1407            for asynchronous request. (optional)
1408        :param str account_id: The external account number (int) or account ID Guid. (required)
1409        :param str custom_field_id: (required)
1410        :param str apply_to_templates:
1411        :return: None
1412                 If the method is called asynchronously,
1413                 returns the request thread.
1414        """
1415
1416        all_params = ['account_id', 'custom_field_id', 'apply_to_templates']
1417        all_params.append('callback')
1418        all_params.append('_return_http_data_only')
1419        all_params.append('_preload_content')
1420        all_params.append('_request_timeout')
1421
1422        params = locals()
1423        for key, val in iteritems(params['kwargs']):
1424            if key not in all_params:
1425                raise TypeError(
1426                    "Got an unexpected keyword argument '%s'"
1427                    " to method delete_custom_field" % key
1428                )
1429            params[key] = val
1430        del params['kwargs']
1431        # verify the required parameter 'account_id' is set
1432        if ('account_id' not in params) or (params['account_id'] is None):
1433            raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`")
1434        # verify the required parameter 'custom_field_id' is set
1435        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
1436            raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`")
1437
1438
1439        collection_formats = {}
1440
1441        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
1442        path_params = {}
1443        if 'account_id' in params:
1444            path_params['accountId'] = params['account_id']
1445        if 'custom_field_id' in params:
1446            path_params['customFieldId'] = params['custom_field_id']
1447
1448        query_params = {}
1449        if 'apply_to_templates' in params:
1450            query_params['apply_to_templates'] = params['apply_to_templates']
1451
1452        header_params = {}
1453
1454        form_params = []
1455        local_var_files = {}
1456
1457        body_params = None
1458        # HTTP header `Accept`
1459        header_params['Accept'] = self.api_client.\
1460            select_header_accept(['application/json'])
1461
1462        # Authentication setting
1463        auth_settings = []
1464
1465        return self.api_client.call_api(resource_path, 'DELETE',
1466                                        path_params,
1467                                        query_params,
1468                                        header_params,
1469                                        body=body_params,
1470                                        post_params=form_params,
1471                                        files=local_var_files,
1472                                        response_type=None,
1473                                        auth_settings=auth_settings,
1474                                        callback=params.get('callback'),
1475                                        _return_http_data_only=params.get('_return_http_data_only'),
1476                                        _preload_content=params.get('_preload_content', True),
1477                                        _request_timeout=params.get('_request_timeout'),
1478                                        collection_formats=collection_formats)

Delete an existing account custom field. This method deletes an existing account custom field. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str custom_field_id: (required)
  • str apply_to_templates:
Returns

None If the method is called asynchronously, returns the request thread.

def delete_e_note_configuration(self, account_id, **kwargs)
1480    def delete_e_note_configuration(self, account_id, **kwargs):
1481        """
1482        Deletes configuration information for the eNote eOriginal integration.
1483        
1484        This method makes a synchronous HTTP request by default. To make an
1485        asynchronous HTTP request, please define a `callback` function
1486        to be invoked when receiving the response.
1487        >>> def callback_function(response):
1488        >>>     pprint(response)
1489        >>>
1490        >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function)
1491
1492        :param callback function: The callback function
1493            for asynchronous request. (optional)
1494        :param str account_id: The external account number (int) or account ID Guid. (required)
1495        :return: None
1496                 If the method is called asynchronously,
1497                 returns the request thread.
1498        """
1499        kwargs['_return_http_data_only'] = True
1500        if kwargs.get('callback'):
1501            return self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1502        else:
1503            (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs)
1504            return data

Deletes configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_e_note_configuration(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_e_note_configuration_with_http_info(self, account_id, **kwargs)
1506    def delete_e_note_configuration_with_http_info(self, account_id, **kwargs):
1507        """
1508        Deletes configuration information for the eNote eOriginal integration.
1509        
1510        This method makes a synchronous HTTP request by default. To make an
1511        asynchronous HTTP request, please define a `callback` function
1512        to be invoked when receiving the response.
1513        >>> def callback_function(response):
1514        >>>     pprint(response)
1515        >>>
1516        >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function)
1517
1518        :param callback function: The callback function
1519            for asynchronous request. (optional)
1520        :param str account_id: The external account number (int) or account ID Guid. (required)
1521        :return: None
1522                 If the method is called asynchronously,
1523                 returns the request thread.
1524        """
1525
1526        all_params = ['account_id']
1527        all_params.append('callback')
1528        all_params.append('_return_http_data_only')
1529        all_params.append('_preload_content')
1530        all_params.append('_request_timeout')
1531
1532        params = locals()
1533        for key, val in iteritems(params['kwargs']):
1534            if key not in all_params:
1535                raise TypeError(
1536                    "Got an unexpected keyword argument '%s'"
1537                    " to method delete_e_note_configuration" % key
1538                )
1539            params[key] = val
1540        del params['kwargs']
1541        # verify the required parameter 'account_id' is set
1542        if ('account_id' not in params) or (params['account_id'] is None):
1543            raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`")
1544
1545
1546        collection_formats = {}
1547
1548        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
1549        path_params = {}
1550        if 'account_id' in params:
1551            path_params['accountId'] = params['account_id']
1552
1553        query_params = {}
1554
1555        header_params = {}
1556
1557        form_params = []
1558        local_var_files = {}
1559
1560        body_params = None
1561        # HTTP header `Accept`
1562        header_params['Accept'] = self.api_client.\
1563            select_header_accept(['application/json'])
1564
1565        # Authentication setting
1566        auth_settings = []
1567
1568        return self.api_client.call_api(resource_path, 'DELETE',
1569                                        path_params,
1570                                        query_params,
1571                                        header_params,
1572                                        body=body_params,
1573                                        post_params=form_params,
1574                                        files=local_var_files,
1575                                        response_type=None,
1576                                        auth_settings=auth_settings,
1577                                        callback=params.get('callback'),
1578                                        _return_http_data_only=params.get('_return_http_data_only'),
1579                                        _preload_content=params.get('_preload_content', True),
1580                                        _request_timeout=params.get('_request_timeout'),
1581                                        collection_formats=collection_formats)

Deletes configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def delete_permission_profile(self, account_id, permission_profile_id, **kwargs)
1583    def delete_permission_profile(self, account_id, permission_profile_id, **kwargs):
1584        """
1585        Deletes a permissions profile within the specified account.
1586        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1587        This method makes a synchronous HTTP request by default. To make an
1588        asynchronous HTTP request, please define a `callback` function
1589        to be invoked when receiving the response.
1590        >>> def callback_function(response):
1591        >>>     pprint(response)
1592        >>>
1593        >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function)
1594
1595        :param callback function: The callback function
1596            for asynchronous request. (optional)
1597        :param str account_id: The external account number (int) or account ID Guid. (required)
1598        :param str permission_profile_id: (required)
1599        :param str move_users_to:
1600        :return: None
1601                 If the method is called asynchronously,
1602                 returns the request thread.
1603        """
1604        kwargs['_return_http_data_only'] = True
1605        if kwargs.get('callback'):
1606            return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1607        else:
1608            (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
1609            return data

Deletes a permissions profile within the specified account. This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str move_users_to:
Returns

None If the method is called asynchronously, returns the request thread.

def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
1611    def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
1612        """
1613        Deletes a permissions profile within the specified account.
1614        This method deletes a permission profile from an account.  To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter.   ### Related topics  - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/)
1615        This method makes a synchronous HTTP request by default. To make an
1616        asynchronous HTTP request, please define a `callback` function
1617        to be invoked when receiving the response.
1618        >>> def callback_function(response):
1619        >>>     pprint(response)
1620        >>>
1621        >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
1622
1623        :param callback function: The callback function
1624            for asynchronous request. (optional)
1625        :param str account_id: The external account number (int) or account ID Guid. (required)
1626        :param str permission_profile_id: (required)
1627        :param str move_users_to:
1628        :return: None
1629                 If the method is called asynchronously,
1630                 returns the request thread.
1631        """
1632
1633        all_params = ['account_id', 'permission_profile_id', 'move_users_to']
1634        all_params.append('callback')
1635        all_params.append('_return_http_data_only')
1636        all_params.append('_preload_content')
1637        all_params.append('_request_timeout')
1638
1639        params = locals()
1640        for key, val in iteritems(params['kwargs']):
1641            if key not in all_params:
1642                raise TypeError(
1643                    "Got an unexpected keyword argument '%s'"
1644                    " to method delete_permission_profile" % key
1645                )
1646            params[key] = val
1647        del params['kwargs']
1648        # verify the required parameter 'account_id' is set
1649        if ('account_id' not in params) or (params['account_id'] is None):
1650            raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`")
1651        # verify the required parameter 'permission_profile_id' is set
1652        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
1653            raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`")
1654
1655
1656        collection_formats = {}
1657
1658        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
1659        path_params = {}
1660        if 'account_id' in params:
1661            path_params['accountId'] = params['account_id']
1662        if 'permission_profile_id' in params:
1663            path_params['permissionProfileId'] = params['permission_profile_id']
1664
1665        query_params = {}
1666        if 'move_users_to' in params:
1667            query_params['move_users_to'] = params['move_users_to']
1668
1669        header_params = {}
1670
1671        form_params = []
1672        local_var_files = {}
1673
1674        body_params = None
1675        # HTTP header `Accept`
1676        header_params['Accept'] = self.api_client.\
1677            select_header_accept(['application/json'])
1678
1679        # Authentication setting
1680        auth_settings = []
1681
1682        return self.api_client.call_api(resource_path, 'DELETE',
1683                                        path_params,
1684                                        query_params,
1685                                        header_params,
1686                                        body=body_params,
1687                                        post_params=form_params,
1688                                        files=local_var_files,
1689                                        response_type=None,
1690                                        auth_settings=auth_settings,
1691                                        callback=params.get('callback'),
1692                                        _return_http_data_only=params.get('_return_http_data_only'),
1693                                        _preload_content=params.get('_preload_content', True),
1694                                        _request_timeout=params.get('_request_timeout'),
1695                                        collection_formats=collection_formats)

Deletes a permissions profile within the specified account. This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str move_users_to:
Returns

None If the method is called asynchronously, returns the request thread.

def get_account_identity_verification(self, account_id, **kwargs)
1697    def get_account_identity_verification(self, account_id, **kwargs):
1698        """
1699        Get the list of identity verification options for an account
1700        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1701        This method makes a synchronous HTTP request by default. To make an
1702        asynchronous HTTP request, please define a `callback` function
1703        to be invoked when receiving the response.
1704        >>> def callback_function(response):
1705        >>>     pprint(response)
1706        >>>
1707        >>> thread = api.get_account_identity_verification(account_id, callback=callback_function)
1708
1709        :param callback function: The callback function
1710            for asynchronous request. (optional)
1711        :param str account_id: The external account number (int) or account ID Guid. (required)
1712        :return: AccountIdentityVerificationResponse
1713                 If the method is called asynchronously,
1714                 returns the request thread.
1715        """
1716        kwargs['_return_http_data_only'] = True
1717        if kwargs.get('callback'):
1718            return self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1719        else:
1720            (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs)
1721            return data

Get the list of identity verification options for an account This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) for a recipient
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_identity_verification(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.

def get_account_identity_verification_with_http_info(self, account_id, **kwargs)
1723    def get_account_identity_verification_with_http_info(self, account_id, **kwargs):
1724        """
1725        Get the list of identity verification options for an account
1726        This method returns a list of Identity Verification workflows that are available to an account.  **Note:** To use this method, you must either be an account administrator or a sender.  ### Related topics  - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/)  
1727        This method makes a synchronous HTTP request by default. To make an
1728        asynchronous HTTP request, please define a `callback` function
1729        to be invoked when receiving the response.
1730        >>> def callback_function(response):
1731        >>>     pprint(response)
1732        >>>
1733        >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function)
1734
1735        :param callback function: The callback function
1736            for asynchronous request. (optional)
1737        :param str account_id: The external account number (int) or account ID Guid. (required)
1738        :return: AccountIdentityVerificationResponse
1739                 If the method is called asynchronously,
1740                 returns the request thread.
1741        """
1742
1743        all_params = ['account_id']
1744        all_params.append('callback')
1745        all_params.append('_return_http_data_only')
1746        all_params.append('_preload_content')
1747        all_params.append('_request_timeout')
1748
1749        params = locals()
1750        for key, val in iteritems(params['kwargs']):
1751            if key not in all_params:
1752                raise TypeError(
1753                    "Got an unexpected keyword argument '%s'"
1754                    " to method get_account_identity_verification" % key
1755                )
1756            params[key] = val
1757        del params['kwargs']
1758        # verify the required parameter 'account_id' is set
1759        if ('account_id' not in params) or (params['account_id'] is None):
1760            raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`")
1761
1762
1763        collection_formats = {}
1764
1765        resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json')
1766        path_params = {}
1767        if 'account_id' in params:
1768            path_params['accountId'] = params['account_id']
1769
1770        query_params = {}
1771
1772        header_params = {}
1773
1774        form_params = []
1775        local_var_files = {}
1776
1777        body_params = None
1778        # HTTP header `Accept`
1779        header_params['Accept'] = self.api_client.\
1780            select_header_accept(['application/json'])
1781
1782        # Authentication setting
1783        auth_settings = []
1784
1785        return self.api_client.call_api(resource_path, 'GET',
1786                                        path_params,
1787                                        query_params,
1788                                        header_params,
1789                                        body=body_params,
1790                                        post_params=form_params,
1791                                        files=local_var_files,
1792                                        response_type='AccountIdentityVerificationResponse',
1793                                        auth_settings=auth_settings,
1794                                        callback=params.get('callback'),
1795                                        _return_http_data_only=params.get('_return_http_data_only'),
1796                                        _preload_content=params.get('_preload_content', True),
1797                                        _request_timeout=params.get('_request_timeout'),
1798                                        collection_formats=collection_formats)

Get the list of identity verification options for an account This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) for a recipient
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.

def get_account_information(self, account_id, **kwargs)
1800    def get_account_information(self, account_id, **kwargs):
1801        """
1802        Retrieves the account information for the specified account.
1803        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1804        This method makes a synchronous HTTP request by default. To make an
1805        asynchronous HTTP request, please define a `callback` function
1806        to be invoked when receiving the response.
1807        >>> def callback_function(response):
1808        >>>     pprint(response)
1809        >>>
1810        >>> thread = api.get_account_information(account_id, callback=callback_function)
1811
1812        :param callback function: The callback function
1813            for asynchronous request. (optional)
1814        :param str account_id: The external account number (int) or account ID Guid. (required)
1815        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1816        :return: AccountInformation
1817                 If the method is called asynchronously,
1818                 returns the request thread.
1819        """
1820        kwargs['_return_http_data_only'] = True
1821        if kwargs.get('callback'):
1822            return self.get_account_information_with_http_info(account_id, **kwargs)
1823        else:
1824            (data) = self.get_account_information_with_http_info(account_id, **kwargs)
1825            return data

Retrieves the account information for the specified account. Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_information(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns

AccountInformation If the method is called asynchronously, returns the request thread.

def get_account_information_with_http_info(self, account_id, **kwargs)
1827    def get_account_information_with_http_info(self, account_id, **kwargs):
1828        """
1829        Retrieves the account information for the specified account.
1830        Retrieves the account information for the specified account.  **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 
1831        This method makes a synchronous HTTP request by default. To make an
1832        asynchronous HTTP request, please define a `callback` function
1833        to be invoked when receiving the response.
1834        >>> def callback_function(response):
1835        >>>     pprint(response)
1836        >>>
1837        >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
1838
1839        :param callback function: The callback function
1840            for asynchronous request. (optional)
1841        :param str account_id: The external account number (int) or account ID Guid. (required)
1842        :param str include_account_settings: When set to **true**, includes the account settings for the account in the response.
1843        :return: AccountInformation
1844                 If the method is called asynchronously,
1845                 returns the request thread.
1846        """
1847
1848        all_params = ['account_id', 'include_account_settings']
1849        all_params.append('callback')
1850        all_params.append('_return_http_data_only')
1851        all_params.append('_preload_content')
1852        all_params.append('_request_timeout')
1853
1854        params = locals()
1855        for key, val in iteritems(params['kwargs']):
1856            if key not in all_params:
1857                raise TypeError(
1858                    "Got an unexpected keyword argument '%s'"
1859                    " to method get_account_information" % key
1860                )
1861            params[key] = val
1862        del params['kwargs']
1863        # verify the required parameter 'account_id' is set
1864        if ('account_id' not in params) or (params['account_id'] is None):
1865            raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`")
1866
1867
1868        collection_formats = {}
1869
1870        resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json')
1871        path_params = {}
1872        if 'account_id' in params:
1873            path_params['accountId'] = params['account_id']
1874
1875        query_params = {}
1876        if 'include_account_settings' in params:
1877            query_params['include_account_settings'] = params['include_account_settings']
1878
1879        header_params = {}
1880
1881        form_params = []
1882        local_var_files = {}
1883
1884        body_params = None
1885        # HTTP header `Accept`
1886        header_params['Accept'] = self.api_client.\
1887            select_header_accept(['application/json'])
1888
1889        # Authentication setting
1890        auth_settings = []
1891
1892        return self.api_client.call_api(resource_path, 'GET',
1893                                        path_params,
1894                                        query_params,
1895                                        header_params,
1896                                        body=body_params,
1897                                        post_params=form_params,
1898                                        files=local_var_files,
1899                                        response_type='AccountInformation',
1900                                        auth_settings=auth_settings,
1901                                        callback=params.get('callback'),
1902                                        _return_http_data_only=params.get('_return_http_data_only'),
1903                                        _preload_content=params.get('_preload_content', True),
1904                                        _request_timeout=params.get('_request_timeout'),
1905                                        collection_formats=collection_formats)

Retrieves the account information for the specified account. Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns

AccountInformation If the method is called asynchronously, returns the request thread.

def get_account_signature(self, account_id, signature_id, **kwargs)
1907    def get_account_signature(self, account_id, signature_id, **kwargs):
1908        """
1909        Returns information about a single signature by specifed signatureId.
1910        
1911        This method makes a synchronous HTTP request by default. To make an
1912        asynchronous HTTP request, please define a `callback` function
1913        to be invoked when receiving the response.
1914        >>> def callback_function(response):
1915        >>>     pprint(response)
1916        >>>
1917        >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function)
1918
1919        :param callback function: The callback function
1920            for asynchronous request. (optional)
1921        :param str account_id: The external account number (int) or account ID Guid. (required)
1922        :param str signature_id: The ID of the signature being accessed. (required)
1923        :return: AccountSignature
1924                 If the method is called asynchronously,
1925                 returns the request thread.
1926        """
1927        kwargs['_return_http_data_only'] = True
1928        if kwargs.get('callback'):
1929            return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1930        else:
1931            (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs)
1932            return data

Returns information about a single signature by specifed signatureId.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
1934    def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs):
1935        """
1936        Returns information about a single signature by specifed signatureId.
1937        
1938        This method makes a synchronous HTTP request by default. To make an
1939        asynchronous HTTP request, please define a `callback` function
1940        to be invoked when receiving the response.
1941        >>> def callback_function(response):
1942        >>>     pprint(response)
1943        >>>
1944        >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
1945
1946        :param callback function: The callback function
1947            for asynchronous request. (optional)
1948        :param str account_id: The external account number (int) or account ID Guid. (required)
1949        :param str signature_id: The ID of the signature being accessed. (required)
1950        :return: AccountSignature
1951                 If the method is called asynchronously,
1952                 returns the request thread.
1953        """
1954
1955        all_params = ['account_id', 'signature_id']
1956        all_params.append('callback')
1957        all_params.append('_return_http_data_only')
1958        all_params.append('_preload_content')
1959        all_params.append('_request_timeout')
1960
1961        params = locals()
1962        for key, val in iteritems(params['kwargs']):
1963            if key not in all_params:
1964                raise TypeError(
1965                    "Got an unexpected keyword argument '%s'"
1966                    " to method get_account_signature" % key
1967                )
1968            params[key] = val
1969        del params['kwargs']
1970        # verify the required parameter 'account_id' is set
1971        if ('account_id' not in params) or (params['account_id'] is None):
1972            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`")
1973        # verify the required parameter 'signature_id' is set
1974        if ('signature_id' not in params) or (params['signature_id'] is None):
1975            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`")
1976
1977
1978        collection_formats = {}
1979
1980        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
1981        path_params = {}
1982        if 'account_id' in params:
1983            path_params['accountId'] = params['account_id']
1984        if 'signature_id' in params:
1985            path_params['signatureId'] = params['signature_id']
1986
1987        query_params = {}
1988
1989        header_params = {}
1990
1991        form_params = []
1992        local_var_files = {}
1993
1994        body_params = None
1995        # HTTP header `Accept`
1996        header_params['Accept'] = self.api_client.\
1997            select_header_accept(['application/json'])
1998
1999        # Authentication setting
2000        auth_settings = []
2001
2002        return self.api_client.call_api(resource_path, 'GET',
2003                                        path_params,
2004                                        query_params,
2005                                        header_params,
2006                                        body=body_params,
2007                                        post_params=form_params,
2008                                        files=local_var_files,
2009                                        response_type='AccountSignature',
2010                                        auth_settings=auth_settings,
2011                                        callback=params.get('callback'),
2012                                        _return_http_data_only=params.get('_return_http_data_only'),
2013                                        _preload_content=params.get('_preload_content', True),
2014                                        _request_timeout=params.get('_request_timeout'),
2015                                        collection_formats=collection_formats)

Returns information about a single signature by specifed signatureId.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
2017    def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
2018        """
2019        Returns a signature, initials, or stamps image.
2020        
2021        This method makes a synchronous HTTP request by default. To make an
2022        asynchronous HTTP request, please define a `callback` function
2023        to be invoked when receiving the response.
2024        >>> def callback_function(response):
2025        >>>     pprint(response)
2026        >>>
2027        >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
2028
2029        :param callback function: The callback function
2030            for asynchronous request. (optional)
2031        :param str account_id: The external account number (int) or account ID Guid. (required)
2032        :param str image_type: One of **signature_image** or **initials_image**. (required)
2033        :param str signature_id: The ID of the signature being accessed. (required)
2034        :param str include_chrome:
2035        :return: file
2036                 If the method is called asynchronously,
2037                 returns the request thread.
2038        """
2039        kwargs['_return_http_data_only'] = True
2040        if kwargs.get('callback'):
2041            return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2042        else:
2043            (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
2044            return data

Returns a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str include_chrome:
Returns

file If the method is called asynchronously, returns the request thread.

def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
2046    def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
2047        """
2048        Returns a signature, initials, or stamps image.
2049        
2050        This method makes a synchronous HTTP request by default. To make an
2051        asynchronous HTTP request, please define a `callback` function
2052        to be invoked when receiving the response.
2053        >>> def callback_function(response):
2054        >>>     pprint(response)
2055        >>>
2056        >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
2057
2058        :param callback function: The callback function
2059            for asynchronous request. (optional)
2060        :param str account_id: The external account number (int) or account ID Guid. (required)
2061        :param str image_type: One of **signature_image** or **initials_image**. (required)
2062        :param str signature_id: The ID of the signature being accessed. (required)
2063        :param str include_chrome:
2064        :return: file
2065                 If the method is called asynchronously,
2066                 returns the request thread.
2067        """
2068
2069        all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome']
2070        all_params.append('callback')
2071        all_params.append('_return_http_data_only')
2072        all_params.append('_preload_content')
2073        all_params.append('_request_timeout')
2074
2075        params = locals()
2076        for key, val in iteritems(params['kwargs']):
2077            if key not in all_params:
2078                raise TypeError(
2079                    "Got an unexpected keyword argument '%s'"
2080                    " to method get_account_signature_image" % key
2081                )
2082            params[key] = val
2083        del params['kwargs']
2084        # verify the required parameter 'account_id' is set
2085        if ('account_id' not in params) or (params['account_id'] is None):
2086            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`")
2087        # verify the required parameter 'image_type' is set
2088        if ('image_type' not in params) or (params['image_type'] is None):
2089            raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`")
2090        # verify the required parameter 'signature_id' is set
2091        if ('signature_id' not in params) or (params['signature_id'] is None):
2092            raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`")
2093
2094
2095        collection_formats = {}
2096
2097        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
2098        path_params = {}
2099        if 'account_id' in params:
2100            path_params['accountId'] = params['account_id']
2101        if 'image_type' in params:
2102            path_params['imageType'] = params['image_type']
2103        if 'signature_id' in params:
2104            path_params['signatureId'] = params['signature_id']
2105
2106        query_params = {}
2107        if 'include_chrome' in params:
2108            query_params['include_chrome'] = params['include_chrome']
2109
2110        header_params = {}
2111
2112        form_params = []
2113        local_var_files = {}
2114
2115        body_params = None
2116        # HTTP header `Accept`
2117        header_params['Accept'] = self.api_client.\
2118            select_header_accept(['image/gif'])
2119
2120        # Authentication setting
2121        auth_settings = []
2122
2123        return self.api_client.call_api(resource_path, 'GET',
2124                                        path_params,
2125                                        query_params,
2126                                        header_params,
2127                                        body=body_params,
2128                                        post_params=form_params,
2129                                        files=local_var_files,
2130                                        response_type='file',
2131                                        auth_settings=auth_settings,
2132                                        callback=params.get('callback'),
2133                                        _return_http_data_only=params.get('_return_http_data_only'),
2134                                        _preload_content=params.get('_preload_content', True),
2135                                        _request_timeout=params.get('_request_timeout'),
2136                                        collection_formats=collection_formats)

Returns a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str include_chrome:
Returns

file If the method is called asynchronously, returns the request thread.

def get_account_signatures(self, account_id, **kwargs)
2138    def get_account_signatures(self, account_id, **kwargs):
2139        """
2140        Returns the managed signature definitions for the account
2141        
2142        This method makes a synchronous HTTP request by default. To make an
2143        asynchronous HTTP request, please define a `callback` function
2144        to be invoked when receiving the response.
2145        >>> def callback_function(response):
2146        >>>     pprint(response)
2147        >>>
2148        >>> thread = api.get_account_signatures(account_id, callback=callback_function)
2149
2150        :param callback function: The callback function
2151            for asynchronous request. (optional)
2152        :param str account_id: The external account number (int) or account ID Guid. (required)
2153        :param str stamp_format:
2154        :param str stamp_name:
2155        :param str stamp_type:
2156        :return: AccountSignaturesInformation
2157                 If the method is called asynchronously,
2158                 returns the request thread.
2159        """
2160        kwargs['_return_http_data_only'] = True
2161        if kwargs.get('callback'):
2162            return self.get_account_signatures_with_http_info(account_id, **kwargs)
2163        else:
2164            (data) = self.get_account_signatures_with_http_info(account_id, **kwargs)
2165            return data

Returns the managed signature definitions for the account

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signatures(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str stamp_format:
  • str stamp_name:
  • str stamp_type:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def get_account_signatures_with_http_info(self, account_id, **kwargs)
2167    def get_account_signatures_with_http_info(self, account_id, **kwargs):
2168        """
2169        Returns the managed signature definitions for the account
2170        
2171        This method makes a synchronous HTTP request by default. To make an
2172        asynchronous HTTP request, please define a `callback` function
2173        to be invoked when receiving the response.
2174        >>> def callback_function(response):
2175        >>>     pprint(response)
2176        >>>
2177        >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function)
2178
2179        :param callback function: The callback function
2180            for asynchronous request. (optional)
2181        :param str account_id: The external account number (int) or account ID Guid. (required)
2182        :param str stamp_format:
2183        :param str stamp_name:
2184        :param str stamp_type:
2185        :return: AccountSignaturesInformation
2186                 If the method is called asynchronously,
2187                 returns the request thread.
2188        """
2189
2190        all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type']
2191        all_params.append('callback')
2192        all_params.append('_return_http_data_only')
2193        all_params.append('_preload_content')
2194        all_params.append('_request_timeout')
2195
2196        params = locals()
2197        for key, val in iteritems(params['kwargs']):
2198            if key not in all_params:
2199                raise TypeError(
2200                    "Got an unexpected keyword argument '%s'"
2201                    " to method get_account_signatures" % key
2202                )
2203            params[key] = val
2204        del params['kwargs']
2205        # verify the required parameter 'account_id' is set
2206        if ('account_id' not in params) or (params['account_id'] is None):
2207            raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`")
2208
2209
2210        collection_formats = {}
2211
2212        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
2213        path_params = {}
2214        if 'account_id' in params:
2215            path_params['accountId'] = params['account_id']
2216
2217        query_params = {}
2218        if 'stamp_format' in params:
2219            query_params['stamp_format'] = params['stamp_format']
2220        if 'stamp_name' in params:
2221            query_params['stamp_name'] = params['stamp_name']
2222        if 'stamp_type' in params:
2223            query_params['stamp_type'] = params['stamp_type']
2224
2225        header_params = {}
2226
2227        form_params = []
2228        local_var_files = {}
2229
2230        body_params = None
2231        # HTTP header `Accept`
2232        header_params['Accept'] = self.api_client.\
2233            select_header_accept(['application/json'])
2234
2235        # Authentication setting
2236        auth_settings = []
2237
2238        return self.api_client.call_api(resource_path, 'GET',
2239                                        path_params,
2240                                        query_params,
2241                                        header_params,
2242                                        body=body_params,
2243                                        post_params=form_params,
2244                                        files=local_var_files,
2245                                        response_type='AccountSignaturesInformation',
2246                                        auth_settings=auth_settings,
2247                                        callback=params.get('callback'),
2248                                        _return_http_data_only=params.get('_return_http_data_only'),
2249                                        _preload_content=params.get('_preload_content', True),
2250                                        _request_timeout=params.get('_request_timeout'),
2251                                        collection_formats=collection_formats)

Returns the managed signature definitions for the account

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str stamp_format:
  • str stamp_name:
  • str stamp_type:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def get_account_tab_settings(self, account_id, **kwargs)
2253    def get_account_tab_settings(self, account_id, **kwargs):
2254        """
2255        Returns tab settings list for specified account
2256        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2257        This method makes a synchronous HTTP request by default. To make an
2258        asynchronous HTTP request, please define a `callback` function
2259        to be invoked when receiving the response.
2260        >>> def callback_function(response):
2261        >>>     pprint(response)
2262        >>>
2263        >>> thread = api.get_account_tab_settings(account_id, callback=callback_function)
2264
2265        :param callback function: The callback function
2266            for asynchronous request. (optional)
2267        :param str account_id: The external account number (int) or account ID Guid. (required)
2268        :return: TabAccountSettings
2269                 If the method is called asynchronously,
2270                 returns the request thread.
2271        """
2272        kwargs['_return_http_data_only'] = True
2273        if kwargs.get('callback'):
2274            return self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2275        else:
2276            (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs)
2277            return data

Returns tab settings list for specified account This method returns information about the tab types and tab functionality that is currently enabled for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_tab_settings(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

TabAccountSettings If the method is called asynchronously, returns the request thread.

def get_account_tab_settings_with_http_info(self, account_id, **kwargs)
2279    def get_account_tab_settings_with_http_info(self, account_id, **kwargs):
2280        """
2281        Returns tab settings list for specified account
2282        This method returns information about the tab types and tab functionality that is currently enabled for an account.
2283        This method makes a synchronous HTTP request by default. To make an
2284        asynchronous HTTP request, please define a `callback` function
2285        to be invoked when receiving the response.
2286        >>> def callback_function(response):
2287        >>>     pprint(response)
2288        >>>
2289        >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function)
2290
2291        :param callback function: The callback function
2292            for asynchronous request. (optional)
2293        :param str account_id: The external account number (int) or account ID Guid. (required)
2294        :return: TabAccountSettings
2295                 If the method is called asynchronously,
2296                 returns the request thread.
2297        """
2298
2299        all_params = ['account_id']
2300        all_params.append('callback')
2301        all_params.append('_return_http_data_only')
2302        all_params.append('_preload_content')
2303        all_params.append('_request_timeout')
2304
2305        params = locals()
2306        for key, val in iteritems(params['kwargs']):
2307            if key not in all_params:
2308                raise TypeError(
2309                    "Got an unexpected keyword argument '%s'"
2310                    " to method get_account_tab_settings" % key
2311                )
2312            params[key] = val
2313        del params['kwargs']
2314        # verify the required parameter 'account_id' is set
2315        if ('account_id' not in params) or (params['account_id'] is None):
2316            raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`")
2317
2318
2319        collection_formats = {}
2320
2321        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
2322        path_params = {}
2323        if 'account_id' in params:
2324            path_params['accountId'] = params['account_id']
2325
2326        query_params = {}
2327
2328        header_params = {}
2329
2330        form_params = []
2331        local_var_files = {}
2332
2333        body_params = None
2334        # HTTP header `Accept`
2335        header_params['Accept'] = self.api_client.\
2336            select_header_accept(['application/json'])
2337
2338        # Authentication setting
2339        auth_settings = []
2340
2341        return self.api_client.call_api(resource_path, 'GET',
2342                                        path_params,
2343                                        query_params,
2344                                        header_params,
2345                                        body=body_params,
2346                                        post_params=form_params,
2347                                        files=local_var_files,
2348                                        response_type='TabAccountSettings',
2349                                        auth_settings=auth_settings,
2350                                        callback=params.get('callback'),
2351                                        _return_http_data_only=params.get('_return_http_data_only'),
2352                                        _preload_content=params.get('_preload_content', True),
2353                                        _request_timeout=params.get('_request_timeout'),
2354                                        collection_formats=collection_formats)

Returns tab settings list for specified account This method returns information about the tab types and tab functionality that is currently enabled for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

TabAccountSettings If the method is called asynchronously, returns the request thread.

def get_all_payment_gateway_accounts(self, account_id, **kwargs)
2356    def get_all_payment_gateway_accounts(self, account_id, **kwargs):
2357        """
2358        Get all payment gateway account for the provided accountId
2359        This method returns a list of payment gateway accounts and basic information about them.
2360        This method makes a synchronous HTTP request by default. To make an
2361        asynchronous HTTP request, please define a `callback` function
2362        to be invoked when receiving the response.
2363        >>> def callback_function(response):
2364        >>>     pprint(response)
2365        >>>
2366        >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function)
2367
2368        :param callback function: The callback function
2369            for asynchronous request. (optional)
2370        :param str account_id: The external account number (int) or account ID Guid. (required)
2371        :return: PaymentGatewayAccountsInfo
2372                 If the method is called asynchronously,
2373                 returns the request thread.
2374        """
2375        kwargs['_return_http_data_only'] = True
2376        if kwargs.get('callback'):
2377            return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2378        else:
2379            (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs)
2380            return data

Get all payment gateway account for the provided accountId This method returns a list of payment gateway accounts and basic information about them. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.

def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs)
2382    def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs):
2383        """
2384        Get all payment gateway account for the provided accountId
2385        This method returns a list of payment gateway accounts and basic information about them.
2386        This method makes a synchronous HTTP request by default. To make an
2387        asynchronous HTTP request, please define a `callback` function
2388        to be invoked when receiving the response.
2389        >>> def callback_function(response):
2390        >>>     pprint(response)
2391        >>>
2392        >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function)
2393
2394        :param callback function: The callback function
2395            for asynchronous request. (optional)
2396        :param str account_id: The external account number (int) or account ID Guid. (required)
2397        :return: PaymentGatewayAccountsInfo
2398                 If the method is called asynchronously,
2399                 returns the request thread.
2400        """
2401
2402        all_params = ['account_id']
2403        all_params.append('callback')
2404        all_params.append('_return_http_data_only')
2405        all_params.append('_preload_content')
2406        all_params.append('_request_timeout')
2407
2408        params = locals()
2409        for key, val in iteritems(params['kwargs']):
2410            if key not in all_params:
2411                raise TypeError(
2412                    "Got an unexpected keyword argument '%s'"
2413                    " to method get_all_payment_gateway_accounts" % key
2414                )
2415            params[key] = val
2416        del params['kwargs']
2417        # verify the required parameter 'account_id' is set
2418        if ('account_id' not in params) or (params['account_id'] is None):
2419            raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`")
2420
2421
2422        collection_formats = {}
2423
2424        resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json')
2425        path_params = {}
2426        if 'account_id' in params:
2427            path_params['accountId'] = params['account_id']
2428
2429        query_params = {}
2430
2431        header_params = {}
2432
2433        form_params = []
2434        local_var_files = {}
2435
2436        body_params = None
2437        # HTTP header `Accept`
2438        header_params['Accept'] = self.api_client.\
2439            select_header_accept(['application/json'])
2440
2441        # Authentication setting
2442        auth_settings = []
2443
2444        return self.api_client.call_api(resource_path, 'GET',
2445                                        path_params,
2446                                        query_params,
2447                                        header_params,
2448                                        body=body_params,
2449                                        post_params=form_params,
2450                                        files=local_var_files,
2451                                        response_type='PaymentGatewayAccountsInfo',
2452                                        auth_settings=auth_settings,
2453                                        callback=params.get('callback'),
2454                                        _return_http_data_only=params.get('_return_http_data_only'),
2455                                        _preload_content=params.get('_preload_content', True),
2456                                        _request_timeout=params.get('_request_timeout'),
2457                                        collection_formats=collection_formats)

Get all payment gateway account for the provided accountId This method returns a list of payment gateway accounts and basic information about them. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.

def get_billing_charges(self, account_id, **kwargs)
2459    def get_billing_charges(self, account_id, **kwargs):
2460        """
2461        Gets list of recurring and usage charges for the account.
2462        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2463        This method makes a synchronous HTTP request by default. To make an
2464        asynchronous HTTP request, please define a `callback` function
2465        to be invoked when receiving the response.
2466        >>> def callback_function(response):
2467        >>>     pprint(response)
2468        >>>
2469        >>> thread = api.get_billing_charges(account_id, callback=callback_function)
2470
2471        :param callback function: The callback function
2472            for asynchronous request. (optional)
2473        :param str account_id: The external account number (int) or account ID Guid. (required)
2474        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2475        :return: BillingChargeResponse
2476                 If the method is called asynchronously,
2477                 returns the request thread.
2478        """
2479        kwargs['_return_http_data_only'] = True
2480        if kwargs.get('callback'):
2481            return self.get_billing_charges_with_http_info(account_id, **kwargs)
2482        else:
2483            (data) = self.get_billing_charges_with_http_info(account_id, **kwargs)
2484            return data

Gets list of recurring and usage charges for the account. Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_billing_charges(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns

BillingChargeResponse If the method is called asynchronously, returns the request thread.

def get_billing_charges_with_http_info(self, account_id, **kwargs)
2486    def get_billing_charges_with_http_info(self, account_id, **kwargs):
2487        """
2488        Gets list of recurring and usage charges for the account.
2489        Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items.   Privileges required: account administrator 
2490        This method makes a synchronous HTTP request by default. To make an
2491        asynchronous HTTP request, please define a `callback` function
2492        to be invoked when receiving the response.
2493        >>> def callback_function(response):
2494        >>>     pprint(response)
2495        >>>
2496        >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function)
2497
2498        :param callback function: The callback function
2499            for asynchronous request. (optional)
2500        :param str account_id: The external account number (int) or account ID Guid. (required)
2501        :param str include_charges: Specifies which billing charges to return. Valid values are:  * envelopes * seats 
2502        :return: BillingChargeResponse
2503                 If the method is called asynchronously,
2504                 returns the request thread.
2505        """
2506
2507        all_params = ['account_id', 'include_charges']
2508        all_params.append('callback')
2509        all_params.append('_return_http_data_only')
2510        all_params.append('_preload_content')
2511        all_params.append('_request_timeout')
2512
2513        params = locals()
2514        for key, val in iteritems(params['kwargs']):
2515            if key not in all_params:
2516                raise TypeError(
2517                    "Got an unexpected keyword argument '%s'"
2518                    " to method get_billing_charges" % key
2519                )
2520            params[key] = val
2521        del params['kwargs']
2522        # verify the required parameter 'account_id' is set
2523        if ('account_id' not in params) or (params['account_id'] is None):
2524            raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`")
2525
2526
2527        collection_formats = {}
2528
2529        resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json')
2530        path_params = {}
2531        if 'account_id' in params:
2532            path_params['accountId'] = params['account_id']
2533
2534        query_params = {}
2535        if 'include_charges' in params:
2536            query_params['include_charges'] = params['include_charges']
2537
2538        header_params = {}
2539
2540        form_params = []
2541        local_var_files = {}
2542
2543        body_params = None
2544        # HTTP header `Accept`
2545        header_params['Accept'] = self.api_client.\
2546            select_header_accept(['application/json'])
2547
2548        # Authentication setting
2549        auth_settings = []
2550
2551        return self.api_client.call_api(resource_path, 'GET',
2552                                        path_params,
2553                                        query_params,
2554                                        header_params,
2555                                        body=body_params,
2556                                        post_params=form_params,
2557                                        files=local_var_files,
2558                                        response_type='BillingChargeResponse',
2559                                        auth_settings=auth_settings,
2560                                        callback=params.get('callback'),
2561                                        _return_http_data_only=params.get('_return_http_data_only'),
2562                                        _preload_content=params.get('_preload_content', True),
2563                                        _request_timeout=params.get('_request_timeout'),
2564                                        collection_formats=collection_formats)

Gets list of recurring and usage charges for the account. Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns

BillingChargeResponse If the method is called asynchronously, returns the request thread.

def get_brand(self, account_id, brand_id, **kwargs)
2566    def get_brand(self, account_id, brand_id, **kwargs):
2567        """
2568        Get information for a specific brand.
2569        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2570        This method makes a synchronous HTTP request by default. To make an
2571        asynchronous HTTP request, please define a `callback` function
2572        to be invoked when receiving the response.
2573        >>> def callback_function(response):
2574        >>>     pprint(response)
2575        >>>
2576        >>> thread = api.get_brand(account_id, brand_id, callback=callback_function)
2577
2578        :param callback function: The callback function
2579            for asynchronous request. (optional)
2580        :param str account_id: The external account number (int) or account ID Guid. (required)
2581        :param str brand_id: The unique identifier of a brand. (required)
2582        :param str include_external_references:
2583        :param str include_logos:
2584        :return: Brand
2585                 If the method is called asynchronously,
2586                 returns the request thread.
2587        """
2588        kwargs['_return_http_data_only'] = True
2589        if kwargs.get('callback'):
2590            return self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2591        else:
2592            (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs)
2593            return data

Get information for a specific brand. This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str include_external_references:
  • str include_logos:
Returns

Brand If the method is called asynchronously, returns the request thread.

def get_brand_with_http_info(self, account_id, brand_id, **kwargs)
2595    def get_brand_with_http_info(self, account_id, brand_id, **kwargs):
2596        """
2597        Get information for a specific brand.
2598        This method returns details about an account brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2599        This method makes a synchronous HTTP request by default. To make an
2600        asynchronous HTTP request, please define a `callback` function
2601        to be invoked when receiving the response.
2602        >>> def callback_function(response):
2603        >>>     pprint(response)
2604        >>>
2605        >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function)
2606
2607        :param callback function: The callback function
2608            for asynchronous request. (optional)
2609        :param str account_id: The external account number (int) or account ID Guid. (required)
2610        :param str brand_id: The unique identifier of a brand. (required)
2611        :param str include_external_references:
2612        :param str include_logos:
2613        :return: Brand
2614                 If the method is called asynchronously,
2615                 returns the request thread.
2616        """
2617
2618        all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos']
2619        all_params.append('callback')
2620        all_params.append('_return_http_data_only')
2621        all_params.append('_preload_content')
2622        all_params.append('_request_timeout')
2623
2624        params = locals()
2625        for key, val in iteritems(params['kwargs']):
2626            if key not in all_params:
2627                raise TypeError(
2628                    "Got an unexpected keyword argument '%s'"
2629                    " to method get_brand" % key
2630                )
2631            params[key] = val
2632        del params['kwargs']
2633        # verify the required parameter 'account_id' is set
2634        if ('account_id' not in params) or (params['account_id'] is None):
2635            raise ValueError("Missing the required parameter `account_id` when calling `get_brand`")
2636        # verify the required parameter 'brand_id' is set
2637        if ('brand_id' not in params) or (params['brand_id'] is None):
2638            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`")
2639
2640
2641        collection_formats = {}
2642
2643        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
2644        path_params = {}
2645        if 'account_id' in params:
2646            path_params['accountId'] = params['account_id']
2647        if 'brand_id' in params:
2648            path_params['brandId'] = params['brand_id']
2649
2650        query_params = {}
2651        if 'include_external_references' in params:
2652            query_params['include_external_references'] = params['include_external_references']
2653        if 'include_logos' in params:
2654            query_params['include_logos'] = params['include_logos']
2655
2656        header_params = {}
2657
2658        form_params = []
2659        local_var_files = {}
2660
2661        body_params = None
2662        # HTTP header `Accept`
2663        header_params['Accept'] = self.api_client.\
2664            select_header_accept(['application/json'])
2665
2666        # Authentication setting
2667        auth_settings = []
2668
2669        return self.api_client.call_api(resource_path, 'GET',
2670                                        path_params,
2671                                        query_params,
2672                                        header_params,
2673                                        body=body_params,
2674                                        post_params=form_params,
2675                                        files=local_var_files,
2676                                        response_type='Brand',
2677                                        auth_settings=auth_settings,
2678                                        callback=params.get('callback'),
2679                                        _return_http_data_only=params.get('_return_http_data_only'),
2680                                        _preload_content=params.get('_preload_content', True),
2681                                        _request_timeout=params.get('_request_timeout'),
2682                                        collection_formats=collection_formats)

Get information for a specific brand. This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str include_external_references:
  • str include_logos:
Returns

Brand If the method is called asynchronously, returns the request thread.

def get_brand_export_file(self, account_id, brand_id, **kwargs)
2684    def get_brand_export_file(self, account_id, brand_id, **kwargs):
2685        """
2686        Export a specific brand.
2687        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2688        This method makes a synchronous HTTP request by default. To make an
2689        asynchronous HTTP request, please define a `callback` function
2690        to be invoked when receiving the response.
2691        >>> def callback_function(response):
2692        >>>     pprint(response)
2693        >>>
2694        >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function)
2695
2696        :param callback function: The callback function
2697            for asynchronous request. (optional)
2698        :param str account_id: The external account number (int) or account ID Guid. (required)
2699        :param str brand_id: The unique identifier of a brand. (required)
2700        :return: None
2701                 If the method is called asynchronously,
2702                 returns the request thread.
2703        """
2704        kwargs['_return_http_data_only'] = True
2705        if kwargs.get('callback'):
2706            return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2707        else:
2708            (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs)
2709            return data

Export a specific brand. This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs)
2711    def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs):
2712        """
2713        Export a specific brand.
2714        This method exports information about a brand to an XML file.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2715        This method makes a synchronous HTTP request by default. To make an
2716        asynchronous HTTP request, please define a `callback` function
2717        to be invoked when receiving the response.
2718        >>> def callback_function(response):
2719        >>>     pprint(response)
2720        >>>
2721        >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
2722
2723        :param callback function: The callback function
2724            for asynchronous request. (optional)
2725        :param str account_id: The external account number (int) or account ID Guid. (required)
2726        :param str brand_id: The unique identifier of a brand. (required)
2727        :return: None
2728                 If the method is called asynchronously,
2729                 returns the request thread.
2730        """
2731
2732        all_params = ['account_id', 'brand_id']
2733        all_params.append('callback')
2734        all_params.append('_return_http_data_only')
2735        all_params.append('_preload_content')
2736        all_params.append('_request_timeout')
2737
2738        params = locals()
2739        for key, val in iteritems(params['kwargs']):
2740            if key not in all_params:
2741                raise TypeError(
2742                    "Got an unexpected keyword argument '%s'"
2743                    " to method get_brand_export_file" % key
2744                )
2745            params[key] = val
2746        del params['kwargs']
2747        # verify the required parameter 'account_id' is set
2748        if ('account_id' not in params) or (params['account_id'] is None):
2749            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`")
2750        # verify the required parameter 'brand_id' is set
2751        if ('brand_id' not in params) or (params['brand_id'] is None):
2752            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`")
2753
2754
2755        collection_formats = {}
2756
2757        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json')
2758        path_params = {}
2759        if 'account_id' in params:
2760            path_params['accountId'] = params['account_id']
2761        if 'brand_id' in params:
2762            path_params['brandId'] = params['brand_id']
2763
2764        query_params = {}
2765
2766        header_params = {}
2767
2768        form_params = []
2769        local_var_files = {}
2770
2771        body_params = None
2772        # HTTP header `Accept`
2773        header_params['Accept'] = self.api_client.\
2774            select_header_accept(['application/json'])
2775
2776        # Authentication setting
2777        auth_settings = []
2778
2779        return self.api_client.call_api(resource_path, 'GET',
2780                                        path_params,
2781                                        query_params,
2782                                        header_params,
2783                                        body=body_params,
2784                                        post_params=form_params,
2785                                        files=local_var_files,
2786                                        response_type=None,
2787                                        auth_settings=auth_settings,
2788                                        callback=params.get('callback'),
2789                                        _return_http_data_only=params.get('_return_http_data_only'),
2790                                        _preload_content=params.get('_preload_content', True),
2791                                        _request_timeout=params.get('_request_timeout'),
2792                                        collection_formats=collection_formats)

Export a specific brand. This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

None If the method is called asynchronously, returns the request thread.

def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
2794    def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs):
2795        """
2796        Obtains the specified image for a brand.
2797        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2798        This method makes a synchronous HTTP request by default. To make an
2799        asynchronous HTTP request, please define a `callback` function
2800        to be invoked when receiving the response.
2801        >>> def callback_function(response):
2802        >>>     pprint(response)
2803        >>>
2804        >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
2805
2806        :param callback function: The callback function
2807            for asynchronous request. (optional)
2808        :param str account_id: The external account number (int) or account ID Guid. (required)
2809        :param str brand_id: The unique identifier of a brand. (required)
2810        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2811        :return: file
2812                 If the method is called asynchronously,
2813                 returns the request thread.
2814        """
2815        kwargs['_return_http_data_only'] = True
2816        if kwargs.get('callback'):
2817            return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2818        else:
2819            (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs)
2820            return data

Obtains the specified image for a brand. This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str logo_type: One of Primary, Secondary or Email. (required)
Returns

file If the method is called asynchronously, returns the request thread.

def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
2822    def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs):
2823        """
2824        Obtains the specified image for a brand.
2825        This method returns a specific logo that is used in a brand.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2826        This method makes a synchronous HTTP request by default. To make an
2827        asynchronous HTTP request, please define a `callback` function
2828        to be invoked when receiving the response.
2829        >>> def callback_function(response):
2830        >>>     pprint(response)
2831        >>>
2832        >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
2833
2834        :param callback function: The callback function
2835            for asynchronous request. (optional)
2836        :param str account_id: The external account number (int) or account ID Guid. (required)
2837        :param str brand_id: The unique identifier of a brand. (required)
2838        :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required)
2839        :return: file
2840                 If the method is called asynchronously,
2841                 returns the request thread.
2842        """
2843
2844        all_params = ['account_id', 'brand_id', 'logo_type']
2845        all_params.append('callback')
2846        all_params.append('_return_http_data_only')
2847        all_params.append('_preload_content')
2848        all_params.append('_request_timeout')
2849
2850        params = locals()
2851        for key, val in iteritems(params['kwargs']):
2852            if key not in all_params:
2853                raise TypeError(
2854                    "Got an unexpected keyword argument '%s'"
2855                    " to method get_brand_logo_by_type" % key
2856                )
2857            params[key] = val
2858        del params['kwargs']
2859        # verify the required parameter 'account_id' is set
2860        if ('account_id' not in params) or (params['account_id'] is None):
2861            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`")
2862        # verify the required parameter 'brand_id' is set
2863        if ('brand_id' not in params) or (params['brand_id'] is None):
2864            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`")
2865        # verify the required parameter 'logo_type' is set
2866        if ('logo_type' not in params) or (params['logo_type'] is None):
2867            raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`")
2868
2869
2870        collection_formats = {}
2871
2872        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
2873        path_params = {}
2874        if 'account_id' in params:
2875            path_params['accountId'] = params['account_id']
2876        if 'brand_id' in params:
2877            path_params['brandId'] = params['brand_id']
2878        if 'logo_type' in params:
2879            path_params['logoType'] = params['logo_type']
2880
2881        query_params = {}
2882
2883        header_params = {}
2884
2885        form_params = []
2886        local_var_files = {}
2887
2888        body_params = None
2889        # HTTP header `Accept`
2890        header_params['Accept'] = self.api_client.\
2891            select_header_accept(['image/png'])
2892
2893        # Authentication setting
2894        auth_settings = []
2895
2896        return self.api_client.call_api(resource_path, 'GET',
2897                                        path_params,
2898                                        query_params,
2899                                        header_params,
2900                                        body=body_params,
2901                                        post_params=form_params,
2902                                        files=local_var_files,
2903                                        response_type='file',
2904                                        auth_settings=auth_settings,
2905                                        callback=params.get('callback'),
2906                                        _return_http_data_only=params.get('_return_http_data_only'),
2907                                        _preload_content=params.get('_preload_content', True),
2908                                        _request_timeout=params.get('_request_timeout'),
2909                                        collection_formats=collection_formats)

Obtains the specified image for a brand. This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str logo_type: One of Primary, Secondary or Email. (required)
Returns

file If the method is called asynchronously, returns the request thread.

def get_brand_resources(self, account_id, brand_id, **kwargs)
2911    def get_brand_resources(self, account_id, brand_id, **kwargs):
2912        """
2913        Returns the specified account's list of branding resources (metadata).
2914        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2915        This method makes a synchronous HTTP request by default. To make an
2916        asynchronous HTTP request, please define a `callback` function
2917        to be invoked when receiving the response.
2918        >>> def callback_function(response):
2919        >>>     pprint(response)
2920        >>>
2921        >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function)
2922
2923        :param callback function: The callback function
2924            for asynchronous request. (optional)
2925        :param str account_id: The external account number (int) or account ID Guid. (required)
2926        :param str brand_id: The unique identifier of a brand. (required)
2927        :return: BrandResourcesList
2928                 If the method is called asynchronously,
2929                 returns the request thread.
2930        """
2931        kwargs['_return_http_data_only'] = True
2932        if kwargs.get('callback'):
2933            return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2934        else:
2935            (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs)
2936            return data

Returns the specified account's list of branding resources (metadata). This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

BrandResourcesList If the method is called asynchronously, returns the request thread.

def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs)
2938    def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs):
2939        """
2940        Returns the specified account's list of branding resources (metadata).
2941        This method returns metadata about the branding resources that are associated with an account.  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
2942        This method makes a synchronous HTTP request by default. To make an
2943        asynchronous HTTP request, please define a `callback` function
2944        to be invoked when receiving the response.
2945        >>> def callback_function(response):
2946        >>>     pprint(response)
2947        >>>
2948        >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
2949
2950        :param callback function: The callback function
2951            for asynchronous request. (optional)
2952        :param str account_id: The external account number (int) or account ID Guid. (required)
2953        :param str brand_id: The unique identifier of a brand. (required)
2954        :return: BrandResourcesList
2955                 If the method is called asynchronously,
2956                 returns the request thread.
2957        """
2958
2959        all_params = ['account_id', 'brand_id']
2960        all_params.append('callback')
2961        all_params.append('_return_http_data_only')
2962        all_params.append('_preload_content')
2963        all_params.append('_request_timeout')
2964
2965        params = locals()
2966        for key, val in iteritems(params['kwargs']):
2967            if key not in all_params:
2968                raise TypeError(
2969                    "Got an unexpected keyword argument '%s'"
2970                    " to method get_brand_resources" % key
2971                )
2972            params[key] = val
2973        del params['kwargs']
2974        # verify the required parameter 'account_id' is set
2975        if ('account_id' not in params) or (params['account_id'] is None):
2976            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`")
2977        # verify the required parameter 'brand_id' is set
2978        if ('brand_id' not in params) or (params['brand_id'] is None):
2979            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`")
2980
2981
2982        collection_formats = {}
2983
2984        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json')
2985        path_params = {}
2986        if 'account_id' in params:
2987            path_params['accountId'] = params['account_id']
2988        if 'brand_id' in params:
2989            path_params['brandId'] = params['brand_id']
2990
2991        query_params = {}
2992
2993        header_params = {}
2994
2995        form_params = []
2996        local_var_files = {}
2997
2998        body_params = None
2999        # HTTP header `Accept`
3000        header_params['Accept'] = self.api_client.\
3001            select_header_accept(['application/json'])
3002
3003        # Authentication setting
3004        auth_settings = []
3005
3006        return self.api_client.call_api(resource_path, 'GET',
3007                                        path_params,
3008                                        query_params,
3009                                        header_params,
3010                                        body=body_params,
3011                                        post_params=form_params,
3012                                        files=local_var_files,
3013                                        response_type='BrandResourcesList',
3014                                        auth_settings=auth_settings,
3015                                        callback=params.get('callback'),
3016                                        _return_http_data_only=params.get('_return_http_data_only'),
3017                                        _preload_content=params.get('_preload_content', True),
3018                                        _request_timeout=params.get('_request_timeout'),
3019                                        collection_formats=collection_formats)

Returns the specified account's list of branding resources (metadata). This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
Returns

BrandResourcesList If the method is called asynchronously, returns the request thread.

def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs)
3021    def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs):
3022        """
3023        Returns the specified branding resource file.
3024        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3025        This method makes a synchronous HTTP request by default. To make an
3026        asynchronous HTTP request, please define a `callback` function
3027        to be invoked when receiving the response.
3028        >>> def callback_function(response):
3029        >>>     pprint(response)
3030        >>>
3031        >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
3032
3033        :param callback function: The callback function
3034            for asynchronous request. (optional)
3035        :param str account_id: The external account number (int) or account ID Guid. (required)
3036        :param str brand_id: The unique identifier of a brand. (required)
3037        :param str resource_content_type: (required)
3038        :param str langcode:
3039        :param str return_master:
3040        :return: None
3041                 If the method is called asynchronously,
3042                 returns the request thread.
3043        """
3044        kwargs['_return_http_data_only'] = True
3045        if kwargs.get('callback'):
3046            return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3047        else:
3048            (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs)
3049            return data

Returns the specified branding resource file. This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str resource_content_type: (required)
  • str langcode:
  • str return_master:
Returns

None If the method is called asynchronously, returns the request thread.

def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs)
3051    def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs):
3052        """
3053        Returns the specified branding resource file.
3054        This method returns a specific branding resource file.  A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences.  You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience.  **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
3055        This method makes a synchronous HTTP request by default. To make an
3056        asynchronous HTTP request, please define a `callback` function
3057        to be invoked when receiving the response.
3058        >>> def callback_function(response):
3059        >>>     pprint(response)
3060        >>>
3061        >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
3062
3063        :param callback function: The callback function
3064            for asynchronous request. (optional)
3065        :param str account_id: The external account number (int) or account ID Guid. (required)
3066        :param str brand_id: The unique identifier of a brand. (required)
3067        :param str resource_content_type: (required)
3068        :param str langcode:
3069        :param str return_master:
3070        :return: None
3071                 If the method is called asynchronously,
3072                 returns the request thread.
3073        """
3074
3075        all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master']
3076        all_params.append('callback')
3077        all_params.append('_return_http_data_only')
3078        all_params.append('_preload_content')
3079        all_params.append('_request_timeout')
3080
3081        params = locals()
3082        for key, val in iteritems(params['kwargs']):
3083            if key not in all_params:
3084                raise TypeError(
3085                    "Got an unexpected keyword argument '%s'"
3086                    " to method get_brand_resources_by_content_type" % key
3087                )
3088            params[key] = val
3089        del params['kwargs']
3090        # verify the required parameter 'account_id' is set
3091        if ('account_id' not in params) or (params['account_id'] is None):
3092            raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`")
3093        # verify the required parameter 'brand_id' is set
3094        if ('brand_id' not in params) or (params['brand_id'] is None):
3095            raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`")
3096        # verify the required parameter 'resource_content_type' is set
3097        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
3098            raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`")
3099
3100
3101        collection_formats = {}
3102
3103        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
3104        path_params = {}
3105        if 'account_id' in params:
3106            path_params['accountId'] = params['account_id']
3107        if 'brand_id' in params:
3108            path_params['brandId'] = params['brand_id']
3109        if 'resource_content_type' in params:
3110            path_params['resourceContentType'] = params['resource_content_type']
3111
3112        query_params = {}
3113        if 'langcode' in params:
3114            query_params['langcode'] = params['langcode']
3115        if 'return_master' in params:
3116            query_params['return_master'] = params['return_master']
3117
3118        header_params = {}
3119
3120        form_params = []
3121        local_var_files = {}
3122
3123        body_params = None
3124        # HTTP header `Accept`
3125        header_params['Accept'] = self.api_client.\
3126            select_header_accept(['application/json'])
3127
3128        # Authentication setting
3129        auth_settings = []
3130
3131        return self.api_client.call_api(resource_path, 'GET',
3132                                        path_params,
3133                                        query_params,
3134                                        header_params,
3135                                        body=body_params,
3136                                        post_params=form_params,
3137                                        files=local_var_files,
3138                                        response_type=None,
3139                                        auth_settings=auth_settings,
3140                                        callback=params.get('callback'),
3141                                        _return_http_data_only=params.get('_return_http_data_only'),
3142                                        _preload_content=params.get('_preload_content', True),
3143                                        _request_timeout=params.get('_request_timeout'),
3144                                        collection_formats=collection_formats)

Returns the specified branding resource file. This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str resource_content_type: (required)
  • str langcode:
  • str return_master:
Returns

None If the method is called asynchronously, returns the request thread.

def get_consumer_disclosure(self, account_id, lang_code, **kwargs)
3146    def get_consumer_disclosure(self, account_id, lang_code, **kwargs):
3147        """
3148        Gets the Electronic Record and Signature Disclosure.
3149        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3150        This method makes a synchronous HTTP request by default. To make an
3151        asynchronous HTTP request, please define a `callback` function
3152        to be invoked when receiving the response.
3153        >>> def callback_function(response):
3154        >>>     pprint(response)
3155        >>>
3156        >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function)
3157
3158        :param callback function: The callback function
3159            for asynchronous request. (optional)
3160        :param str account_id: The external account number (int) or account ID Guid. (required)
3161        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3162        :return: ConsumerDisclosure
3163                 If the method is called asynchronously,
3164                 returns the request thread.
3165        """
3166        kwargs['_return_http_data_only'] = True
3167        if kwargs.get('callback'):
3168            return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3169        else:
3170            (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
3171            return data

Gets the Electronic Record and Signature Disclosure. Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
3173    def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
3174        """
3175        Gets the Electronic Record and Signature Disclosure.
3176        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.  
3177        This method makes a synchronous HTTP request by default. To make an
3178        asynchronous HTTP request, please define a `callback` function
3179        to be invoked when receiving the response.
3180        >>> def callback_function(response):
3181        >>>     pprint(response)
3182        >>>
3183        >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
3184
3185        :param callback function: The callback function
3186            for asynchronous request. (optional)
3187        :param str account_id: The external account number (int) or account ID Guid. (required)
3188        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
3189        :return: ConsumerDisclosure
3190                 If the method is called asynchronously,
3191                 returns the request thread.
3192        """
3193
3194        all_params = ['account_id', 'lang_code']
3195        all_params.append('callback')
3196        all_params.append('_return_http_data_only')
3197        all_params.append('_preload_content')
3198        all_params.append('_request_timeout')
3199
3200        params = locals()
3201        for key, val in iteritems(params['kwargs']):
3202            if key not in all_params:
3203                raise TypeError(
3204                    "Got an unexpected keyword argument '%s'"
3205                    " to method get_consumer_disclosure" % key
3206                )
3207            params[key] = val
3208        del params['kwargs']
3209        # verify the required parameter 'account_id' is set
3210        if ('account_id' not in params) or (params['account_id'] is None):
3211            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`")
3212        # verify the required parameter 'lang_code' is set
3213        if ('lang_code' not in params) or (params['lang_code'] is None):
3214            raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`")
3215
3216
3217        collection_formats = {}
3218
3219        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
3220        path_params = {}
3221        if 'account_id' in params:
3222            path_params['accountId'] = params['account_id']
3223        if 'lang_code' in params:
3224            path_params['langCode'] = params['lang_code']
3225
3226        query_params = {}
3227
3228        header_params = {}
3229
3230        form_params = []
3231        local_var_files = {}
3232
3233        body_params = None
3234        # HTTP header `Accept`
3235        header_params['Accept'] = self.api_client.\
3236            select_header_accept(['application/json'])
3237
3238        # Authentication setting
3239        auth_settings = []
3240
3241        return self.api_client.call_api(resource_path, 'GET',
3242                                        path_params,
3243                                        query_params,
3244                                        header_params,
3245                                        body=body_params,
3246                                        post_params=form_params,
3247                                        files=local_var_files,
3248                                        response_type='ConsumerDisclosure',
3249                                        auth_settings=auth_settings,
3250                                        callback=params.get('callback'),
3251                                        _return_http_data_only=params.get('_return_http_data_only'),
3252                                        _preload_content=params.get('_preload_content', True),
3253                                        _request_timeout=params.get('_request_timeout'),
3254                                        collection_formats=collection_formats)

Gets the Electronic Record and Signature Disclosure. Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def get_consumer_disclosure_default(self, account_id, **kwargs)
3256    def get_consumer_disclosure_default(self, account_id, **kwargs):
3257        """
3258        Gets the Electronic Record and Signature Disclosure for the account.
3259        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3260        This method makes a synchronous HTTP request by default. To make an
3261        asynchronous HTTP request, please define a `callback` function
3262        to be invoked when receiving the response.
3263        >>> def callback_function(response):
3264        >>>     pprint(response)
3265        >>>
3266        >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function)
3267
3268        :param callback function: The callback function
3269            for asynchronous request. (optional)
3270        :param str account_id: The external account number (int) or account ID Guid. (required)
3271        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3272        :return: ConsumerDisclosure
3273                 If the method is called asynchronously,
3274                 returns the request thread.
3275        """
3276        kwargs['_return_http_data_only'] = True
3277        if kwargs.get('callback'):
3278            return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3279        else:
3280            (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs)
3281            return data

Gets the Electronic Record and Signature Disclosure for the account. Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to browser to automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs)
3283    def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs):
3284        """
3285        Gets the Electronic Record and Signature Disclosure for the account.
3286        Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
3287        This method makes a synchronous HTTP request by default. To make an
3288        asynchronous HTTP request, please define a `callback` function
3289        to be invoked when receiving the response.
3290        >>> def callback_function(response):
3291        >>>     pprint(response)
3292        >>>
3293        >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function)
3294
3295        :param callback function: The callback function
3296            for asynchronous request. (optional)
3297        :param str account_id: The external account number (int) or account ID Guid. (required)
3298        :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi).  Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 
3299        :return: ConsumerDisclosure
3300                 If the method is called asynchronously,
3301                 returns the request thread.
3302        """
3303
3304        all_params = ['account_id', 'lang_code']
3305        all_params.append('callback')
3306        all_params.append('_return_http_data_only')
3307        all_params.append('_preload_content')
3308        all_params.append('_request_timeout')
3309
3310        params = locals()
3311        for key, val in iteritems(params['kwargs']):
3312            if key not in all_params:
3313                raise TypeError(
3314                    "Got an unexpected keyword argument '%s'"
3315                    " to method get_consumer_disclosure_default" % key
3316                )
3317            params[key] = val
3318        del params['kwargs']
3319        # verify the required parameter 'account_id' is set
3320        if ('account_id' not in params) or (params['account_id'] is None):
3321            raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`")
3322
3323
3324        collection_formats = {}
3325
3326        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json')
3327        path_params = {}
3328        if 'account_id' in params:
3329            path_params['accountId'] = params['account_id']
3330
3331        query_params = {}
3332        if 'lang_code' in params:
3333            query_params['langCode'] = params['lang_code']
3334
3335        header_params = {}
3336
3337        form_params = []
3338        local_var_files = {}
3339
3340        body_params = None
3341        # HTTP header `Accept`
3342        header_params['Accept'] = self.api_client.\
3343            select_header_accept(['application/json'])
3344
3345        # Authentication setting
3346        auth_settings = []
3347
3348        return self.api_client.call_api(resource_path, 'GET',
3349                                        path_params,
3350                                        query_params,
3351                                        header_params,
3352                                        body=body_params,
3353                                        post_params=form_params,
3354                                        files=local_var_files,
3355                                        response_type='ConsumerDisclosure',
3356                                        auth_settings=auth_settings,
3357                                        callback=params.get('callback'),
3358                                        _return_http_data_only=params.get('_return_http_data_only'),
3359                                        _preload_content=params.get('_preload_content', True),
3360                                        _request_timeout=params.get('_request_timeout'),
3361                                        collection_formats=collection_formats)

Gets the Electronic Record and Signature Disclosure for the account. Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to browser to automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def get_e_note_configuration(self, account_id, **kwargs)
3363    def get_e_note_configuration(self, account_id, **kwargs):
3364        """
3365        Returns the configuration information for the eNote eOriginal integration.
3366        
3367        This method makes a synchronous HTTP request by default. To make an
3368        asynchronous HTTP request, please define a `callback` function
3369        to be invoked when receiving the response.
3370        >>> def callback_function(response):
3371        >>>     pprint(response)
3372        >>>
3373        >>> thread = api.get_e_note_configuration(account_id, callback=callback_function)
3374
3375        :param callback function: The callback function
3376            for asynchronous request. (optional)
3377        :param str account_id: The external account number (int) or account ID Guid. (required)
3378        :return: ENoteConfiguration
3379                 If the method is called asynchronously,
3380                 returns the request thread.
3381        """
3382        kwargs['_return_http_data_only'] = True
3383        if kwargs.get('callback'):
3384            return self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3385        else:
3386            (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs)
3387            return data

Returns the configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_e_note_configuration(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

ENoteConfiguration If the method is called asynchronously, returns the request thread.

def get_e_note_configuration_with_http_info(self, account_id, **kwargs)
3389    def get_e_note_configuration_with_http_info(self, account_id, **kwargs):
3390        """
3391        Returns the configuration information for the eNote eOriginal integration.
3392        
3393        This method makes a synchronous HTTP request by default. To make an
3394        asynchronous HTTP request, please define a `callback` function
3395        to be invoked when receiving the response.
3396        >>> def callback_function(response):
3397        >>>     pprint(response)
3398        >>>
3399        >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function)
3400
3401        :param callback function: The callback function
3402            for asynchronous request. (optional)
3403        :param str account_id: The external account number (int) or account ID Guid. (required)
3404        :return: ENoteConfiguration
3405                 If the method is called asynchronously,
3406                 returns the request thread.
3407        """
3408
3409        all_params = ['account_id']
3410        all_params.append('callback')
3411        all_params.append('_return_http_data_only')
3412        all_params.append('_preload_content')
3413        all_params.append('_request_timeout')
3414
3415        params = locals()
3416        for key, val in iteritems(params['kwargs']):
3417            if key not in all_params:
3418                raise TypeError(
3419                    "Got an unexpected keyword argument '%s'"
3420                    " to method get_e_note_configuration" % key
3421                )
3422            params[key] = val
3423        del params['kwargs']
3424        # verify the required parameter 'account_id' is set
3425        if ('account_id' not in params) or (params['account_id'] is None):
3426            raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`")
3427
3428
3429        collection_formats = {}
3430
3431        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
3432        path_params = {}
3433        if 'account_id' in params:
3434            path_params['accountId'] = params['account_id']
3435
3436        query_params = {}
3437
3438        header_params = {}
3439
3440        form_params = []
3441        local_var_files = {}
3442
3443        body_params = None
3444        # HTTP header `Accept`
3445        header_params['Accept'] = self.api_client.\
3446            select_header_accept(['application/json'])
3447
3448        # Authentication setting
3449        auth_settings = []
3450
3451        return self.api_client.call_api(resource_path, 'GET',
3452                                        path_params,
3453                                        query_params,
3454                                        header_params,
3455                                        body=body_params,
3456                                        post_params=form_params,
3457                                        files=local_var_files,
3458                                        response_type='ENoteConfiguration',
3459                                        auth_settings=auth_settings,
3460                                        callback=params.get('callback'),
3461                                        _return_http_data_only=params.get('_return_http_data_only'),
3462                                        _preload_content=params.get('_preload_content', True),
3463                                        _request_timeout=params.get('_request_timeout'),
3464                                        collection_formats=collection_formats)

Returns the configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

ENoteConfiguration If the method is called asynchronously, returns the request thread.

def get_envelope_purge_configuration(self, account_id, **kwargs)
3466    def get_envelope_purge_configuration(self, account_id, **kwargs):
3467        """
3468        Select envelope purge configuration.
3469        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3470        This method makes a synchronous HTTP request by default. To make an
3471        asynchronous HTTP request, please define a `callback` function
3472        to be invoked when receiving the response.
3473        >>> def callback_function(response):
3474        >>>     pprint(response)
3475        >>>
3476        >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function)
3477
3478        :param callback function: The callback function
3479            for asynchronous request. (optional)
3480        :param str account_id: The external account number (int) or account ID Guid. (required)
3481        :return: EnvelopePurgeConfiguration
3482                 If the method is called asynchronously,
3483                 returns the request thread.
3484        """
3485        kwargs['_return_http_data_only'] = True
3486        if kwargs.get('callback'):
3487            return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3488        else:
3489            (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs)
3490            return data

Select envelope purge configuration. An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.

def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
3492    def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
3493        """
3494        Select envelope purge configuration.
3495        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.
3496        This method makes a synchronous HTTP request by default. To make an
3497        asynchronous HTTP request, please define a `callback` function
3498        to be invoked when receiving the response.
3499        >>> def callback_function(response):
3500        >>>     pprint(response)
3501        >>>
3502        >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
3503
3504        :param callback function: The callback function
3505            for asynchronous request. (optional)
3506        :param str account_id: The external account number (int) or account ID Guid. (required)
3507        :return: EnvelopePurgeConfiguration
3508                 If the method is called asynchronously,
3509                 returns the request thread.
3510        """
3511
3512        all_params = ['account_id']
3513        all_params.append('callback')
3514        all_params.append('_return_http_data_only')
3515        all_params.append('_preload_content')
3516        all_params.append('_request_timeout')
3517
3518        params = locals()
3519        for key, val in iteritems(params['kwargs']):
3520            if key not in all_params:
3521                raise TypeError(
3522                    "Got an unexpected keyword argument '%s'"
3523                    " to method get_envelope_purge_configuration" % key
3524                )
3525            params[key] = val
3526        del params['kwargs']
3527        # verify the required parameter 'account_id' is set
3528        if ('account_id' not in params) or (params['account_id'] is None):
3529            raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`")
3530
3531
3532        collection_formats = {}
3533
3534        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
3535        path_params = {}
3536        if 'account_id' in params:
3537            path_params['accountId'] = params['account_id']
3538
3539        query_params = {}
3540
3541        header_params = {}
3542
3543        form_params = []
3544        local_var_files = {}
3545
3546        body_params = None
3547        # HTTP header `Accept`
3548        header_params['Accept'] = self.api_client.\
3549            select_header_accept(['application/json'])
3550
3551        # Authentication setting
3552        auth_settings = []
3553
3554        return self.api_client.call_api(resource_path, 'GET',
3555                                        path_params,
3556                                        query_params,
3557                                        header_params,
3558                                        body=body_params,
3559                                        post_params=form_params,
3560                                        files=local_var_files,
3561                                        response_type='EnvelopePurgeConfiguration',
3562                                        auth_settings=auth_settings,
3563                                        callback=params.get('callback'),
3564                                        _return_http_data_only=params.get('_return_http_data_only'),
3565                                        _preload_content=params.get('_preload_content', True),
3566                                        _request_timeout=params.get('_request_timeout'),
3567                                        collection_formats=collection_formats)

Select envelope purge configuration. An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.

def get_favorite_templates(self, account_id, **kwargs)
3569    def get_favorite_templates(self, account_id, **kwargs):
3570        """
3571        Retrieves the list of favorited templates for this caller
3572        
3573        This method makes a synchronous HTTP request by default. To make an
3574        asynchronous HTTP request, please define a `callback` function
3575        to be invoked when receiving the response.
3576        >>> def callback_function(response):
3577        >>>     pprint(response)
3578        >>>
3579        >>> thread = api.get_favorite_templates(account_id, callback=callback_function)
3580
3581        :param callback function: The callback function
3582            for asynchronous request. (optional)
3583        :param str account_id: The external account number (int) or account ID Guid. (required)
3584        :return: FavoriteTemplatesInfo
3585                 If the method is called asynchronously,
3586                 returns the request thread.
3587        """
3588        kwargs['_return_http_data_only'] = True
3589        if kwargs.get('callback'):
3590            return self.get_favorite_templates_with_http_info(account_id, **kwargs)
3591        else:
3592            (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs)
3593            return data

Retrieves the list of favorited templates for this caller

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_favorite_templates(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def get_favorite_templates_with_http_info(self, account_id, **kwargs)
3595    def get_favorite_templates_with_http_info(self, account_id, **kwargs):
3596        """
3597        Retrieves the list of favorited templates for this caller
3598        
3599        This method makes a synchronous HTTP request by default. To make an
3600        asynchronous HTTP request, please define a `callback` function
3601        to be invoked when receiving the response.
3602        >>> def callback_function(response):
3603        >>>     pprint(response)
3604        >>>
3605        >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function)
3606
3607        :param callback function: The callback function
3608            for asynchronous request. (optional)
3609        :param str account_id: The external account number (int) or account ID Guid. (required)
3610        :return: FavoriteTemplatesInfo
3611                 If the method is called asynchronously,
3612                 returns the request thread.
3613        """
3614
3615        all_params = ['account_id']
3616        all_params.append('callback')
3617        all_params.append('_return_http_data_only')
3618        all_params.append('_preload_content')
3619        all_params.append('_request_timeout')
3620
3621        params = locals()
3622        for key, val in iteritems(params['kwargs']):
3623            if key not in all_params:
3624                raise TypeError(
3625                    "Got an unexpected keyword argument '%s'"
3626                    " to method get_favorite_templates" % key
3627                )
3628            params[key] = val
3629        del params['kwargs']
3630        # verify the required parameter 'account_id' is set
3631        if ('account_id' not in params) or (params['account_id'] is None):
3632            raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`")
3633
3634
3635        collection_formats = {}
3636
3637        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
3638        path_params = {}
3639        if 'account_id' in params:
3640            path_params['accountId'] = params['account_id']
3641
3642        query_params = {}
3643
3644        header_params = {}
3645
3646        form_params = []
3647        local_var_files = {}
3648
3649        body_params = None
3650        # HTTP header `Accept`
3651        header_params['Accept'] = self.api_client.\
3652            select_header_accept(['application/json'])
3653
3654        # Authentication setting
3655        auth_settings = []
3656
3657        return self.api_client.call_api(resource_path, 'GET',
3658                                        path_params,
3659                                        query_params,
3660                                        header_params,
3661                                        body=body_params,
3662                                        post_params=form_params,
3663                                        files=local_var_files,
3664                                        response_type='FavoriteTemplatesInfo',
3665                                        auth_settings=auth_settings,
3666                                        callback=params.get('callback'),
3667                                        _return_http_data_only=params.get('_return_http_data_only'),
3668                                        _preload_content=params.get('_preload_content', True),
3669                                        _request_timeout=params.get('_request_timeout'),
3670                                        collection_formats=collection_formats)

Retrieves the list of favorited templates for this caller

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def get_notification_defaults(self, account_id, **kwargs)
3672    def get_notification_defaults(self, account_id, **kwargs):
3673        """
3674        Returns default user level settings for a specified account
3675        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3676        This method makes a synchronous HTTP request by default. To make an
3677        asynchronous HTTP request, please define a `callback` function
3678        to be invoked when receiving the response.
3679        >>> def callback_function(response):
3680        >>>     pprint(response)
3681        >>>
3682        >>> thread = api.get_notification_defaults(account_id, callback=callback_function)
3683
3684        :param callback function: The callback function
3685            for asynchronous request. (optional)
3686        :param str account_id: The external account number (int) or account ID Guid. (required)
3687        :return: NotificationDefaults
3688                 If the method is called asynchronously,
3689                 returns the request thread.
3690        """
3691        kwargs['_return_http_data_only'] = True
3692        if kwargs.get('callback'):
3693            return self.get_notification_defaults_with_http_info(account_id, **kwargs)
3694        else:
3695            (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs)
3696            return data

Returns default user level settings for a specified account This method returns the default settings for the email notifications that signers and senders receive about envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_notification_defaults(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

NotificationDefaults If the method is called asynchronously, returns the request thread.

def get_notification_defaults_with_http_info(self, account_id, **kwargs)
3698    def get_notification_defaults_with_http_info(self, account_id, **kwargs):
3699        """
3700        Returns default user level settings for a specified account
3701        This method returns the default settings for the email notifications that signers and senders receive about envelopes.
3702        This method makes a synchronous HTTP request by default. To make an
3703        asynchronous HTTP request, please define a `callback` function
3704        to be invoked when receiving the response.
3705        >>> def callback_function(response):
3706        >>>     pprint(response)
3707        >>>
3708        >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function)
3709
3710        :param callback function: The callback function
3711            for asynchronous request. (optional)
3712        :param str account_id: The external account number (int) or account ID Guid. (required)
3713        :return: NotificationDefaults
3714                 If the method is called asynchronously,
3715                 returns the request thread.
3716        """
3717
3718        all_params = ['account_id']
3719        all_params.append('callback')
3720        all_params.append('_return_http_data_only')
3721        all_params.append('_preload_content')
3722        all_params.append('_request_timeout')
3723
3724        params = locals()
3725        for key, val in iteritems(params['kwargs']):
3726            if key not in all_params:
3727                raise TypeError(
3728                    "Got an unexpected keyword argument '%s'"
3729                    " to method get_notification_defaults" % key
3730                )
3731            params[key] = val
3732        del params['kwargs']
3733        # verify the required parameter 'account_id' is set
3734        if ('account_id' not in params) or (params['account_id'] is None):
3735            raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`")
3736
3737
3738        collection_formats = {}
3739
3740        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
3741        path_params = {}
3742        if 'account_id' in params:
3743            path_params['accountId'] = params['account_id']
3744
3745        query_params = {}
3746
3747        header_params = {}
3748
3749        form_params = []
3750        local_var_files = {}
3751
3752        body_params = None
3753        # HTTP header `Accept`
3754        header_params['Accept'] = self.api_client.\
3755            select_header_accept(['application/json'])
3756
3757        # Authentication setting
3758        auth_settings = []
3759
3760        return self.api_client.call_api(resource_path, 'GET',
3761                                        path_params,
3762                                        query_params,
3763                                        header_params,
3764                                        body=body_params,
3765                                        post_params=form_params,
3766                                        files=local_var_files,
3767                                        response_type='NotificationDefaults',
3768                                        auth_settings=auth_settings,
3769                                        callback=params.get('callback'),
3770                                        _return_http_data_only=params.get('_return_http_data_only'),
3771                                        _preload_content=params.get('_preload_content', True),
3772                                        _request_timeout=params.get('_request_timeout'),
3773                                        collection_formats=collection_formats)

Returns default user level settings for a specified account This method returns the default settings for the email notifications that signers and senders receive about envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

NotificationDefaults If the method is called asynchronously, returns the request thread.

def get_password_rules(self, account_id, **kwargs)
3775    def get_password_rules(self, account_id, **kwargs):
3776        """
3777        Get the password rules
3778        This method retrieves the password rules for an account.
3779        This method makes a synchronous HTTP request by default. To make an
3780        asynchronous HTTP request, please define a `callback` function
3781        to be invoked when receiving the response.
3782        >>> def callback_function(response):
3783        >>>     pprint(response)
3784        >>>
3785        >>> thread = api.get_password_rules(account_id, callback=callback_function)
3786
3787        :param callback function: The callback function
3788            for asynchronous request. (optional)
3789        :param str account_id: The external account number (int) or account ID Guid. (required)
3790        :return: AccountPasswordRules
3791                 If the method is called asynchronously,
3792                 returns the request thread.
3793        """
3794        kwargs['_return_http_data_only'] = True
3795        if kwargs.get('callback'):
3796            return self.get_password_rules_with_http_info(account_id, **kwargs)
3797        else:
3798            (data) = self.get_password_rules_with_http_info(account_id, **kwargs)
3799            return data

Get the password rules This method retrieves the password rules for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_password_rules(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountPasswordRules If the method is called asynchronously, returns the request thread.

def get_password_rules_with_http_info(self, account_id, **kwargs)
3801    def get_password_rules_with_http_info(self, account_id, **kwargs):
3802        """
3803        Get the password rules
3804        This method retrieves the password rules for an account.
3805        This method makes a synchronous HTTP request by default. To make an
3806        asynchronous HTTP request, please define a `callback` function
3807        to be invoked when receiving the response.
3808        >>> def callback_function(response):
3809        >>>     pprint(response)
3810        >>>
3811        >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function)
3812
3813        :param callback function: The callback function
3814            for asynchronous request. (optional)
3815        :param str account_id: The external account number (int) or account ID Guid. (required)
3816        :return: AccountPasswordRules
3817                 If the method is called asynchronously,
3818                 returns the request thread.
3819        """
3820
3821        all_params = ['account_id']
3822        all_params.append('callback')
3823        all_params.append('_return_http_data_only')
3824        all_params.append('_preload_content')
3825        all_params.append('_request_timeout')
3826
3827        params = locals()
3828        for key, val in iteritems(params['kwargs']):
3829            if key not in all_params:
3830                raise TypeError(
3831                    "Got an unexpected keyword argument '%s'"
3832                    " to method get_password_rules" % key
3833                )
3834            params[key] = val
3835        del params['kwargs']
3836        # verify the required parameter 'account_id' is set
3837        if ('account_id' not in params) or (params['account_id'] is None):
3838            raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`")
3839
3840
3841        collection_formats = {}
3842
3843        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
3844        path_params = {}
3845        if 'account_id' in params:
3846            path_params['accountId'] = params['account_id']
3847
3848        query_params = {}
3849
3850        header_params = {}
3851
3852        form_params = []
3853        local_var_files = {}
3854
3855        body_params = None
3856        # HTTP header `Accept`
3857        header_params['Accept'] = self.api_client.\
3858            select_header_accept(['application/json'])
3859
3860        # Authentication setting
3861        auth_settings = []
3862
3863        return self.api_client.call_api(resource_path, 'GET',
3864                                        path_params,
3865                                        query_params,
3866                                        header_params,
3867                                        body=body_params,
3868                                        post_params=form_params,
3869                                        files=local_var_files,
3870                                        response_type='AccountPasswordRules',
3871                                        auth_settings=auth_settings,
3872                                        callback=params.get('callback'),
3873                                        _return_http_data_only=params.get('_return_http_data_only'),
3874                                        _preload_content=params.get('_preload_content', True),
3875                                        _request_timeout=params.get('_request_timeout'),
3876                                        collection_formats=collection_formats)

Get the password rules This method retrieves the password rules for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountPasswordRules If the method is called asynchronously, returns the request thread.

def get_password_rules_0(self, **kwargs)
3878    def get_password_rules_0(self, **kwargs):
3879        """
3880        Get membership account password rules
3881        
3882        This method makes a synchronous HTTP request by default. To make an
3883        asynchronous HTTP request, please define a `callback` function
3884        to be invoked when receiving the response.
3885        >>> def callback_function(response):
3886        >>>     pprint(response)
3887        >>>
3888        >>> thread = api.get_password_rules_0(callback=callback_function)
3889
3890        :param callback function: The callback function
3891            for asynchronous request. (optional)
3892        :return: UserPasswordRules
3893                 If the method is called asynchronously,
3894                 returns the request thread.
3895        """
3896        kwargs['_return_http_data_only'] = True
3897        if kwargs.get('callback'):
3898            return self.get_password_rules_0_with_http_info(**kwargs)
3899        else:
3900            (data) = self.get_password_rules_0_with_http_info(**kwargs)
3901            return data

Get membership account password rules

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_password_rules_0(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
Returns

UserPasswordRules If the method is called asynchronously, returns the request thread.

def get_password_rules_0_with_http_info(self, **kwargs)
3903    def get_password_rules_0_with_http_info(self, **kwargs):
3904        """
3905        Get membership account password rules
3906        
3907        This method makes a synchronous HTTP request by default. To make an
3908        asynchronous HTTP request, please define a `callback` function
3909        to be invoked when receiving the response.
3910        >>> def callback_function(response):
3911        >>>     pprint(response)
3912        >>>
3913        >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function)
3914
3915        :param callback function: The callback function
3916            for asynchronous request. (optional)
3917        :return: UserPasswordRules
3918                 If the method is called asynchronously,
3919                 returns the request thread.
3920        """
3921
3922        all_params = []
3923        all_params.append('callback')
3924        all_params.append('_return_http_data_only')
3925        all_params.append('_preload_content')
3926        all_params.append('_request_timeout')
3927
3928        params = locals()
3929        for key, val in iteritems(params['kwargs']):
3930            if key not in all_params:
3931                raise TypeError(
3932                    "Got an unexpected keyword argument '%s'"
3933                    " to method get_password_rules_0" % key
3934                )
3935            params[key] = val
3936        del params['kwargs']
3937
3938        collection_formats = {}
3939
3940        resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json')
3941        path_params = {}
3942
3943        query_params = {}
3944
3945        header_params = {}
3946
3947        form_params = []
3948        local_var_files = {}
3949
3950        body_params = None
3951        # HTTP header `Accept`
3952        header_params['Accept'] = self.api_client.\
3953            select_header_accept(['application/json'])
3954
3955        # Authentication setting
3956        auth_settings = []
3957
3958        return self.api_client.call_api(resource_path, 'GET',
3959                                        path_params,
3960                                        query_params,
3961                                        header_params,
3962                                        body=body_params,
3963                                        post_params=form_params,
3964                                        files=local_var_files,
3965                                        response_type='UserPasswordRules',
3966                                        auth_settings=auth_settings,
3967                                        callback=params.get('callback'),
3968                                        _return_http_data_only=params.get('_return_http_data_only'),
3969                                        _preload_content=params.get('_preload_content', True),
3970                                        _request_timeout=params.get('_request_timeout'),
3971                                        collection_formats=collection_formats)

Get membership account password rules

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_password_rules_0_with_http_info(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
Returns

UserPasswordRules If the method is called asynchronously, returns the request thread.

def get_permission_profile(self, account_id, permission_profile_id, **kwargs)
3973    def get_permission_profile(self, account_id, permission_profile_id, **kwargs):
3974        """
3975        Returns a permissions profile in the specified account.
3976        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
3977        This method makes a synchronous HTTP request by default. To make an
3978        asynchronous HTTP request, please define a `callback` function
3979        to be invoked when receiving the response.
3980        >>> def callback_function(response):
3981        >>>     pprint(response)
3982        >>>
3983        >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function)
3984
3985        :param callback function: The callback function
3986            for asynchronous request. (optional)
3987        :param str account_id: The external account number (int) or account ID Guid. (required)
3988        :param str permission_profile_id: (required)
3989        :param str include:
3990        :return: PermissionProfile
3991                 If the method is called asynchronously,
3992                 returns the request thread.
3993        """
3994        kwargs['_return_http_data_only'] = True
3995        if kwargs.get('callback'):
3996            return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3997        else:
3998            (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
3999            return data

Returns a permissions profile in the specified account. This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str include:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
4001    def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
4002        """
4003        Returns a permissions profile in the specified account.
4004        This method returns information about a specific permission profile that is associated with an account.  ### Related topics  - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 
4005        This method makes a synchronous HTTP request by default. To make an
4006        asynchronous HTTP request, please define a `callback` function
4007        to be invoked when receiving the response.
4008        >>> def callback_function(response):
4009        >>>     pprint(response)
4010        >>>
4011        >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
4012
4013        :param callback function: The callback function
4014            for asynchronous request. (optional)
4015        :param str account_id: The external account number (int) or account ID Guid. (required)
4016        :param str permission_profile_id: (required)
4017        :param str include:
4018        :return: PermissionProfile
4019                 If the method is called asynchronously,
4020                 returns the request thread.
4021        """
4022
4023        all_params = ['account_id', 'permission_profile_id', 'include']
4024        all_params.append('callback')
4025        all_params.append('_return_http_data_only')
4026        all_params.append('_preload_content')
4027        all_params.append('_request_timeout')
4028
4029        params = locals()
4030        for key, val in iteritems(params['kwargs']):
4031            if key not in all_params:
4032                raise TypeError(
4033                    "Got an unexpected keyword argument '%s'"
4034                    " to method get_permission_profile" % key
4035                )
4036            params[key] = val
4037        del params['kwargs']
4038        # verify the required parameter 'account_id' is set
4039        if ('account_id' not in params) or (params['account_id'] is None):
4040            raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`")
4041        # verify the required parameter 'permission_profile_id' is set
4042        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
4043            raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`")
4044
4045
4046        collection_formats = {}
4047
4048        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
4049        path_params = {}
4050        if 'account_id' in params:
4051            path_params['accountId'] = params['account_id']
4052        if 'permission_profile_id' in params:
4053            path_params['permissionProfileId'] = params['permission_profile_id']
4054
4055        query_params = {}
4056        if 'include' in params:
4057            query_params['include'] = params['include']
4058
4059        header_params = {}
4060
4061        form_params = []
4062        local_var_files = {}
4063
4064        body_params = None
4065        # HTTP header `Accept`
4066        header_params['Accept'] = self.api_client.\
4067            select_header_accept(['application/json'])
4068
4069        # Authentication setting
4070        auth_settings = []
4071
4072        return self.api_client.call_api(resource_path, 'GET',
4073                                        path_params,
4074                                        query_params,
4075                                        header_params,
4076                                        body=body_params,
4077                                        post_params=form_params,
4078                                        files=local_var_files,
4079                                        response_type='PermissionProfile',
4080                                        auth_settings=auth_settings,
4081                                        callback=params.get('callback'),
4082                                        _return_http_data_only=params.get('_return_http_data_only'),
4083                                        _preload_content=params.get('_preload_content', True),
4084                                        _request_timeout=params.get('_request_timeout'),
4085                                        collection_formats=collection_formats)

Returns a permissions profile in the specified account. This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str include:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def get_provisioning(self, **kwargs)
4087    def get_provisioning(self, **kwargs):
4088        """
4089        Retrieves the account provisioning information for the account.
4090        Retrieves the account provisioning information for the account.
4091        This method makes a synchronous HTTP request by default. To make an
4092        asynchronous HTTP request, please define a `callback` function
4093        to be invoked when receiving the response.
4094        >>> def callback_function(response):
4095        >>>     pprint(response)
4096        >>>
4097        >>> thread = api.get_provisioning(callback=callback_function)
4098
4099        :param callback function: The callback function
4100            for asynchronous request. (optional)
4101        :return: ProvisioningInformation
4102                 If the method is called asynchronously,
4103                 returns the request thread.
4104        """
4105        kwargs['_return_http_data_only'] = True
4106        if kwargs.get('callback'):
4107            return self.get_provisioning_with_http_info(**kwargs)
4108        else:
4109            (data) = self.get_provisioning_with_http_info(**kwargs)
4110            return data

Retrieves the account provisioning information for the account. Retrieves the account provisioning information for the account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_provisioning(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
Returns

ProvisioningInformation If the method is called asynchronously, returns the request thread.

def get_provisioning_with_http_info(self, **kwargs)
4112    def get_provisioning_with_http_info(self, **kwargs):
4113        """
4114        Retrieves the account provisioning information for the account.
4115        Retrieves the account provisioning information for the account.
4116        This method makes a synchronous HTTP request by default. To make an
4117        asynchronous HTTP request, please define a `callback` function
4118        to be invoked when receiving the response.
4119        >>> def callback_function(response):
4120        >>>     pprint(response)
4121        >>>
4122        >>> thread = api.get_provisioning_with_http_info(callback=callback_function)
4123
4124        :param callback function: The callback function
4125            for asynchronous request. (optional)
4126        :return: ProvisioningInformation
4127                 If the method is called asynchronously,
4128                 returns the request thread.
4129        """
4130
4131        all_params = []
4132        all_params.append('callback')
4133        all_params.append('_return_http_data_only')
4134        all_params.append('_preload_content')
4135        all_params.append('_request_timeout')
4136
4137        params = locals()
4138        for key, val in iteritems(params['kwargs']):
4139            if key not in all_params:
4140                raise TypeError(
4141                    "Got an unexpected keyword argument '%s'"
4142                    " to method get_provisioning" % key
4143                )
4144            params[key] = val
4145        del params['kwargs']
4146
4147        collection_formats = {}
4148
4149        resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json')
4150        path_params = {}
4151
4152        query_params = {}
4153
4154        header_params = {}
4155
4156        form_params = []
4157        local_var_files = {}
4158
4159        body_params = None
4160        # HTTP header `Accept`
4161        header_params['Accept'] = self.api_client.\
4162            select_header_accept(['application/json'])
4163
4164        # Authentication setting
4165        auth_settings = []
4166
4167        return self.api_client.call_api(resource_path, 'GET',
4168                                        path_params,
4169                                        query_params,
4170                                        header_params,
4171                                        body=body_params,
4172                                        post_params=form_params,
4173                                        files=local_var_files,
4174                                        response_type='ProvisioningInformation',
4175                                        auth_settings=auth_settings,
4176                                        callback=params.get('callback'),
4177                                        _return_http_data_only=params.get('_return_http_data_only'),
4178                                        _preload_content=params.get('_preload_content', True),
4179                                        _request_timeout=params.get('_request_timeout'),
4180                                        collection_formats=collection_formats)

Retrieves the account provisioning information for the account. Retrieves the account provisioning information for the account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_provisioning_with_http_info(callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
Returns

ProvisioningInformation If the method is called asynchronously, returns the request thread.

def get_supported_languages(self, account_id, **kwargs)
4182    def get_supported_languages(self, account_id, **kwargs):
4183        """
4184        Gets list of supported languages for recipient language setting.
4185        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4186        This method makes a synchronous HTTP request by default. To make an
4187        asynchronous HTTP request, please define a `callback` function
4188        to be invoked when receiving the response.
4189        >>> def callback_function(response):
4190        >>>     pprint(response)
4191        >>>
4192        >>> thread = api.get_supported_languages(account_id, callback=callback_function)
4193
4194        :param callback function: The callback function
4195            for asynchronous request. (optional)
4196        :param str account_id: The external account number (int) or account ID Guid. (required)
4197        :return: SupportedLanguages
4198                 If the method is called asynchronously,
4199                 returns the request thread.
4200        """
4201        kwargs['_return_http_data_only'] = True
4202        if kwargs.get('callback'):
4203            return self.get_supported_languages_with_http_info(account_id, **kwargs)
4204        else:
4205            (data) = self.get_supported_languages_with_http_info(account_id, **kwargs)
4206            return data

Gets list of supported languages for recipient language setting. Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom Email Messages. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_supported_languages(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

SupportedLanguages If the method is called asynchronously, returns the request thread.

def get_supported_languages_with_http_info(self, account_id, **kwargs)
4208    def get_supported_languages_with_http_info(self, account_id, **kwargs):
4209        """
4210        Gets list of supported languages for recipient language setting.
4211        Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient.  For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience.  **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it.  For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language).
4212        This method makes a synchronous HTTP request by default. To make an
4213        asynchronous HTTP request, please define a `callback` function
4214        to be invoked when receiving the response.
4215        >>> def callback_function(response):
4216        >>>     pprint(response)
4217        >>>
4218        >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function)
4219
4220        :param callback function: The callback function
4221            for asynchronous request. (optional)
4222        :param str account_id: The external account number (int) or account ID Guid. (required)
4223        :return: SupportedLanguages
4224                 If the method is called asynchronously,
4225                 returns the request thread.
4226        """
4227
4228        all_params = ['account_id']
4229        all_params.append('callback')
4230        all_params.append('_return_http_data_only')
4231        all_params.append('_preload_content')
4232        all_params.append('_request_timeout')
4233
4234        params = locals()
4235        for key, val in iteritems(params['kwargs']):
4236            if key not in all_params:
4237                raise TypeError(
4238                    "Got an unexpected keyword argument '%s'"
4239                    " to method get_supported_languages" % key
4240                )
4241            params[key] = val
4242        del params['kwargs']
4243        # verify the required parameter 'account_id' is set
4244        if ('account_id' not in params) or (params['account_id'] is None):
4245            raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`")
4246
4247
4248        collection_formats = {}
4249
4250        resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json')
4251        path_params = {}
4252        if 'account_id' in params:
4253            path_params['accountId'] = params['account_id']
4254
4255        query_params = {}
4256
4257        header_params = {}
4258
4259        form_params = []
4260        local_var_files = {}
4261
4262        body_params = None
4263        # HTTP header `Accept`
4264        header_params['Accept'] = self.api_client.\
4265            select_header_accept(['application/json'])
4266
4267        # Authentication setting
4268        auth_settings = []
4269
4270        return self.api_client.call_api(resource_path, 'GET',
4271                                        path_params,
4272                                        query_params,
4273                                        header_params,
4274                                        body=body_params,
4275                                        post_params=form_params,
4276                                        files=local_var_files,
4277                                        response_type='SupportedLanguages',
4278                                        auth_settings=auth_settings,
4279                                        callback=params.get('callback'),
4280                                        _return_http_data_only=params.get('_return_http_data_only'),
4281                                        _preload_content=params.get('_preload_content', True),
4282                                        _request_timeout=params.get('_request_timeout'),
4283                                        collection_formats=collection_formats)

Gets list of supported languages for recipient language setting. Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom Email Messages. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

SupportedLanguages If the method is called asynchronously, returns the request thread.

def get_watermark(self, account_id, **kwargs)
4285    def get_watermark(self, account_id, **kwargs):
4286        """
4287        Get watermark information.
4288        
4289        This method makes a synchronous HTTP request by default. To make an
4290        asynchronous HTTP request, please define a `callback` function
4291        to be invoked when receiving the response.
4292        >>> def callback_function(response):
4293        >>>     pprint(response)
4294        >>>
4295        >>> thread = api.get_watermark(account_id, callback=callback_function)
4296
4297        :param callback function: The callback function
4298            for asynchronous request. (optional)
4299        :param str account_id: The external account number (int) or account ID Guid. (required)
4300        :return: Watermark
4301                 If the method is called asynchronously,
4302                 returns the request thread.
4303        """
4304        kwargs['_return_http_data_only'] = True
4305        if kwargs.get('callback'):
4306            return self.get_watermark_with_http_info(account_id, **kwargs)
4307        else:
4308            (data) = self.get_watermark_with_http_info(account_id, **kwargs)
4309            return data

Get watermark information.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_watermark(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

Watermark If the method is called asynchronously, returns the request thread.

def get_watermark_with_http_info(self, account_id, **kwargs)
4311    def get_watermark_with_http_info(self, account_id, **kwargs):
4312        """
4313        Get watermark information.
4314        
4315        This method makes a synchronous HTTP request by default. To make an
4316        asynchronous HTTP request, please define a `callback` function
4317        to be invoked when receiving the response.
4318        >>> def callback_function(response):
4319        >>>     pprint(response)
4320        >>>
4321        >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function)
4322
4323        :param callback function: The callback function
4324            for asynchronous request. (optional)
4325        :param str account_id: The external account number (int) or account ID Guid. (required)
4326        :return: Watermark
4327                 If the method is called asynchronously,
4328                 returns the request thread.
4329        """
4330
4331        all_params = ['account_id']
4332        all_params.append('callback')
4333        all_params.append('_return_http_data_only')
4334        all_params.append('_preload_content')
4335        all_params.append('_request_timeout')
4336
4337        params = locals()
4338        for key, val in iteritems(params['kwargs']):
4339            if key not in all_params:
4340                raise TypeError(
4341                    "Got an unexpected keyword argument '%s'"
4342                    " to method get_watermark" % key
4343                )
4344            params[key] = val
4345        del params['kwargs']
4346        # verify the required parameter 'account_id' is set
4347        if ('account_id' not in params) or (params['account_id'] is None):
4348            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`")
4349
4350
4351        collection_formats = {}
4352
4353        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
4354        path_params = {}
4355        if 'account_id' in params:
4356            path_params['accountId'] = params['account_id']
4357
4358        query_params = {}
4359
4360        header_params = {}
4361
4362        form_params = []
4363        local_var_files = {}
4364
4365        body_params = None
4366        # HTTP header `Accept`
4367        header_params['Accept'] = self.api_client.\
4368            select_header_accept(['application/json'])
4369
4370        # Authentication setting
4371        auth_settings = []
4372
4373        return self.api_client.call_api(resource_path, 'GET',
4374                                        path_params,
4375                                        query_params,
4376                                        header_params,
4377                                        body=body_params,
4378                                        post_params=form_params,
4379                                        files=local_var_files,
4380                                        response_type='Watermark',
4381                                        auth_settings=auth_settings,
4382                                        callback=params.get('callback'),
4383                                        _return_http_data_only=params.get('_return_http_data_only'),
4384                                        _preload_content=params.get('_preload_content', True),
4385                                        _request_timeout=params.get('_request_timeout'),
4386                                        collection_formats=collection_formats)

Get watermark information.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

Watermark If the method is called asynchronously, returns the request thread.

def get_watermark_preview(self, account_id, **kwargs)
4388    def get_watermark_preview(self, account_id, **kwargs):
4389        """
4390        Get watermark preview.
4391        
4392        This method makes a synchronous HTTP request by default. To make an
4393        asynchronous HTTP request, please define a `callback` function
4394        to be invoked when receiving the response.
4395        >>> def callback_function(response):
4396        >>>     pprint(response)
4397        >>>
4398        >>> thread = api.get_watermark_preview(account_id, callback=callback_function)
4399
4400        :param callback function: The callback function
4401            for asynchronous request. (optional)
4402        :param str account_id: The external account number (int) or account ID Guid. (required)
4403        :param Watermark watermark:
4404        :return: Watermark
4405                 If the method is called asynchronously,
4406                 returns the request thread.
4407        """
4408        kwargs['_return_http_data_only'] = True
4409        if kwargs.get('callback'):
4410            return self.get_watermark_preview_with_http_info(account_id, **kwargs)
4411        else:
4412            (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs)
4413            return data

Get watermark preview.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_watermark_preview(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • Watermark watermark:
Returns

Watermark If the method is called asynchronously, returns the request thread.

def get_watermark_preview_with_http_info(self, account_id, **kwargs)
4415    def get_watermark_preview_with_http_info(self, account_id, **kwargs):
4416        """
4417        Get watermark preview.
4418        
4419        This method makes a synchronous HTTP request by default. To make an
4420        asynchronous HTTP request, please define a `callback` function
4421        to be invoked when receiving the response.
4422        >>> def callback_function(response):
4423        >>>     pprint(response)
4424        >>>
4425        >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function)
4426
4427        :param callback function: The callback function
4428            for asynchronous request. (optional)
4429        :param str account_id: The external account number (int) or account ID Guid. (required)
4430        :param Watermark watermark:
4431        :return: Watermark
4432                 If the method is called asynchronously,
4433                 returns the request thread.
4434        """
4435
4436        all_params = ['account_id', 'watermark']
4437        all_params.append('callback')
4438        all_params.append('_return_http_data_only')
4439        all_params.append('_preload_content')
4440        all_params.append('_request_timeout')
4441
4442        params = locals()
4443        for key, val in iteritems(params['kwargs']):
4444            if key not in all_params:
4445                raise TypeError(
4446                    "Got an unexpected keyword argument '%s'"
4447                    " to method get_watermark_preview" % key
4448                )
4449            params[key] = val
4450        del params['kwargs']
4451        # verify the required parameter 'account_id' is set
4452        if ('account_id' not in params) or (params['account_id'] is None):
4453            raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`")
4454
4455
4456        collection_formats = {}
4457
4458        resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json')
4459        path_params = {}
4460        if 'account_id' in params:
4461            path_params['accountId'] = params['account_id']
4462
4463        query_params = {}
4464
4465        header_params = {}
4466
4467        form_params = []
4468        local_var_files = {}
4469
4470        body_params = None
4471        if 'watermark' in params:
4472            body_params = params['watermark']
4473        # HTTP header `Accept`
4474        header_params['Accept'] = self.api_client.\
4475            select_header_accept(['application/json'])
4476
4477        # Authentication setting
4478        auth_settings = []
4479
4480        return self.api_client.call_api(resource_path, 'PUT',
4481                                        path_params,
4482                                        query_params,
4483                                        header_params,
4484                                        body=body_params,
4485                                        post_params=form_params,
4486                                        files=local_var_files,
4487                                        response_type='Watermark',
4488                                        auth_settings=auth_settings,
4489                                        callback=params.get('callback'),
4490                                        _return_http_data_only=params.get('_return_http_data_only'),
4491                                        _preload_content=params.get('_preload_content', True),
4492                                        _request_timeout=params.get('_request_timeout'),
4493                                        collection_formats=collection_formats)

Get watermark preview.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • Watermark watermark:
Returns

Watermark If the method is called asynchronously, returns the request thread.

def list_brands(self, account_id, **kwargs)
4495    def list_brands(self, account_id, **kwargs):
4496        """
4497        Gets a list of brand profiles.
4498        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4499        This method makes a synchronous HTTP request by default. To make an
4500        asynchronous HTTP request, please define a `callback` function
4501        to be invoked when receiving the response.
4502        >>> def callback_function(response):
4503        >>>     pprint(response)
4504        >>>
4505        >>> thread = api.list_brands(account_id, callback=callback_function)
4506
4507        :param callback function: The callback function
4508            for asynchronous request. (optional)
4509        :param str account_id: The external account number (int) or account ID Guid. (required)
4510        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4511        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4512        :return: BrandsResponse
4513                 If the method is called asynchronously,
4514                 returns the request thread.
4515        """
4516        kwargs['_return_http_data_only'] = True
4517        if kwargs.get('callback'):
4518            return self.list_brands_with_http_info(account_id, **kwargs)
4519        else:
4520            (data) = self.list_brands_with_http_info(account_id, **kwargs)
4521            return data

Gets a list of brand profiles. Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_brands(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
  • str include_logos: When set to true, returns the logos associated with the brand.
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def list_brands_with_http_info(self, account_id, **kwargs)
4523    def list_brands_with_http_info(self, account_id, **kwargs):
4524        """
4525        Gets a list of brand profiles.
4526        Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`)  must be set to **true** for the account to use this call.
4527        This method makes a synchronous HTTP request by default. To make an
4528        asynchronous HTTP request, please define a `callback` function
4529        to be invoked when receiving the response.
4530        >>> def callback_function(response):
4531        >>>     pprint(response)
4532        >>>
4533        >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function)
4534
4535        :param callback function: The callback function
4536            for asynchronous request. (optional)
4537        :param str account_id: The external account number (int) or account ID Guid. (required)
4538        :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set.
4539        :param str include_logos: When set to **true**, returns the logos associated with the brand.
4540        :return: BrandsResponse
4541                 If the method is called asynchronously,
4542                 returns the request thread.
4543        """
4544
4545        all_params = ['account_id', 'exclude_distributor_brand', 'include_logos']
4546        all_params.append('callback')
4547        all_params.append('_return_http_data_only')
4548        all_params.append('_preload_content')
4549        all_params.append('_request_timeout')
4550
4551        params = locals()
4552        for key, val in iteritems(params['kwargs']):
4553            if key not in all_params:
4554                raise TypeError(
4555                    "Got an unexpected keyword argument '%s'"
4556                    " to method list_brands" % key
4557                )
4558            params[key] = val
4559        del params['kwargs']
4560        # verify the required parameter 'account_id' is set
4561        if ('account_id' not in params) or (params['account_id'] is None):
4562            raise ValueError("Missing the required parameter `account_id` when calling `list_brands`")
4563
4564
4565        collection_formats = {}
4566
4567        resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json')
4568        path_params = {}
4569        if 'account_id' in params:
4570            path_params['accountId'] = params['account_id']
4571
4572        query_params = {}
4573        if 'exclude_distributor_brand' in params:
4574            query_params['exclude_distributor_brand'] = params['exclude_distributor_brand']
4575        if 'include_logos' in params:
4576            query_params['include_logos'] = params['include_logos']
4577
4578        header_params = {}
4579
4580        form_params = []
4581        local_var_files = {}
4582
4583        body_params = None
4584        # HTTP header `Accept`
4585        header_params['Accept'] = self.api_client.\
4586            select_header_accept(['application/json'])
4587
4588        # Authentication setting
4589        auth_settings = []
4590
4591        return self.api_client.call_api(resource_path, 'GET',
4592                                        path_params,
4593                                        query_params,
4594                                        header_params,
4595                                        body=body_params,
4596                                        post_params=form_params,
4597                                        files=local_var_files,
4598                                        response_type='BrandsResponse',
4599                                        auth_settings=auth_settings,
4600                                        callback=params.get('callback'),
4601                                        _return_http_data_only=params.get('_return_http_data_only'),
4602                                        _preload_content=params.get('_preload_content', True),
4603                                        _request_timeout=params.get('_request_timeout'),
4604                                        collection_formats=collection_formats)

Gets a list of brand profiles. Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_brands_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
  • str include_logos: When set to true, returns the logos associated with the brand.
Returns

BrandsResponse If the method is called asynchronously, returns the request thread.

def list_custom_fields(self, account_id, **kwargs)
4606    def list_custom_fields(self, account_id, **kwargs):
4607        """
4608        Gets a list of custom fields associated with the account.
4609        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4610        This method makes a synchronous HTTP request by default. To make an
4611        asynchronous HTTP request, please define a `callback` function
4612        to be invoked when receiving the response.
4613        >>> def callback_function(response):
4614        >>>     pprint(response)
4615        >>>
4616        >>> thread = api.list_custom_fields(account_id, callback=callback_function)
4617
4618        :param callback function: The callback function
4619            for asynchronous request. (optional)
4620        :param str account_id: The external account number (int) or account ID Guid. (required)
4621        :return: CustomFields
4622                 If the method is called asynchronously,
4623                 returns the request thread.
4624        """
4625        kwargs['_return_http_data_only'] = True
4626        if kwargs.get('callback'):
4627            return self.list_custom_fields_with_http_info(account_id, **kwargs)
4628        else:
4629            (data) = self.list_custom_fields_with_http_info(account_id, **kwargs)
4630            return data

Gets a list of custom fields associated with the account. Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_custom_fields(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def list_custom_fields_with_http_info(self, account_id, **kwargs)
4632    def list_custom_fields_with_http_info(self, account_id, **kwargs):
4633        """
4634        Gets a list of custom fields associated with the account.
4635        Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients.  There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
4636        This method makes a synchronous HTTP request by default. To make an
4637        asynchronous HTTP request, please define a `callback` function
4638        to be invoked when receiving the response.
4639        >>> def callback_function(response):
4640        >>>     pprint(response)
4641        >>>
4642        >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function)
4643
4644        :param callback function: The callback function
4645            for asynchronous request. (optional)
4646        :param str account_id: The external account number (int) or account ID Guid. (required)
4647        :return: CustomFields
4648                 If the method is called asynchronously,
4649                 returns the request thread.
4650        """
4651
4652        all_params = ['account_id']
4653        all_params.append('callback')
4654        all_params.append('_return_http_data_only')
4655        all_params.append('_preload_content')
4656        all_params.append('_request_timeout')
4657
4658        params = locals()
4659        for key, val in iteritems(params['kwargs']):
4660            if key not in all_params:
4661                raise TypeError(
4662                    "Got an unexpected keyword argument '%s'"
4663                    " to method list_custom_fields" % key
4664                )
4665            params[key] = val
4666        del params['kwargs']
4667        # verify the required parameter 'account_id' is set
4668        if ('account_id' not in params) or (params['account_id'] is None):
4669            raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`")
4670
4671
4672        collection_formats = {}
4673
4674        resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json')
4675        path_params = {}
4676        if 'account_id' in params:
4677            path_params['accountId'] = params['account_id']
4678
4679        query_params = {}
4680
4681        header_params = {}
4682
4683        form_params = []
4684        local_var_files = {}
4685
4686        body_params = None
4687        # HTTP header `Accept`
4688        header_params['Accept'] = self.api_client.\
4689            select_header_accept(['application/json'])
4690
4691        # Authentication setting
4692        auth_settings = []
4693
4694        return self.api_client.call_api(resource_path, 'GET',
4695                                        path_params,
4696                                        query_params,
4697                                        header_params,
4698                                        body=body_params,
4699                                        post_params=form_params,
4700                                        files=local_var_files,
4701                                        response_type='CustomFields',
4702                                        auth_settings=auth_settings,
4703                                        callback=params.get('callback'),
4704                                        _return_http_data_only=params.get('_return_http_data_only'),
4705                                        _preload_content=params.get('_preload_content', True),
4706                                        _request_timeout=params.get('_request_timeout'),
4707                                        collection_formats=collection_formats)

Gets a list of custom fields associated with the account. Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def list_permissions(self, account_id, **kwargs)
4709    def list_permissions(self, account_id, **kwargs):
4710        """
4711        Gets a list of permission profiles.
4712        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4713        This method makes a synchronous HTTP request by default. To make an
4714        asynchronous HTTP request, please define a `callback` function
4715        to be invoked when receiving the response.
4716        >>> def callback_function(response):
4717        >>>     pprint(response)
4718        >>>
4719        >>> thread = api.list_permissions(account_id, callback=callback_function)
4720
4721        :param callback function: The callback function
4722            for asynchronous request. (optional)
4723        :param str account_id: The external account number (int) or account ID Guid. (required)
4724        :param str include:
4725        :return: PermissionProfileInformation
4726                 If the method is called asynchronously,
4727                 returns the request thread.
4728        """
4729        kwargs['_return_http_data_only'] = True
4730        if kwargs.get('callback'):
4731            return self.list_permissions_with_http_info(account_id, **kwargs)
4732        else:
4733            (data) = self.list_permissions_with_http_info(account_id, **kwargs)
4734            return data

Gets a list of permission profiles. Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_permissions(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include:
Returns

PermissionProfileInformation If the method is called asynchronously, returns the request thread.

def list_permissions_with_http_info(self, account_id, **kwargs)
4736    def list_permissions_with_http_info(self, account_id, **kwargs):
4737        """
4738        Gets a list of permission profiles.
4739        Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis.  Currently, Permission Profiles can only be created and modified in the DocuSign console.
4740        This method makes a synchronous HTTP request by default. To make an
4741        asynchronous HTTP request, please define a `callback` function
4742        to be invoked when receiving the response.
4743        >>> def callback_function(response):
4744        >>>     pprint(response)
4745        >>>
4746        >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
4747
4748        :param callback function: The callback function
4749            for asynchronous request. (optional)
4750        :param str account_id: The external account number (int) or account ID Guid. (required)
4751        :param str include:
4752        :return: PermissionProfileInformation
4753                 If the method is called asynchronously,
4754                 returns the request thread.
4755        """
4756
4757        all_params = ['account_id', 'include']
4758        all_params.append('callback')
4759        all_params.append('_return_http_data_only')
4760        all_params.append('_preload_content')
4761        all_params.append('_request_timeout')
4762
4763        params = locals()
4764        for key, val in iteritems(params['kwargs']):
4765            if key not in all_params:
4766                raise TypeError(
4767                    "Got an unexpected keyword argument '%s'"
4768                    " to method list_permissions" % key
4769                )
4770            params[key] = val
4771        del params['kwargs']
4772        # verify the required parameter 'account_id' is set
4773        if ('account_id' not in params) or (params['account_id'] is None):
4774            raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`")
4775
4776
4777        collection_formats = {}
4778
4779        resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json')
4780        path_params = {}
4781        if 'account_id' in params:
4782            path_params['accountId'] = params['account_id']
4783
4784        query_params = {}
4785        if 'include' in params:
4786            query_params['include'] = params['include']
4787
4788        header_params = {}
4789
4790        form_params = []
4791        local_var_files = {}
4792
4793        body_params = None
4794        # HTTP header `Accept`
4795        header_params['Accept'] = self.api_client.\
4796            select_header_accept(['application/json'])
4797
4798        # Authentication setting
4799        auth_settings = []
4800
4801        return self.api_client.call_api(resource_path, 'GET',
4802                                        path_params,
4803                                        query_params,
4804                                        header_params,
4805                                        body=body_params,
4806                                        post_params=form_params,
4807                                        files=local_var_files,
4808                                        response_type='PermissionProfileInformation',
4809                                        auth_settings=auth_settings,
4810                                        callback=params.get('callback'),
4811                                        _return_http_data_only=params.get('_return_http_data_only'),
4812                                        _preload_content=params.get('_preload_content', True),
4813                                        _request_timeout=params.get('_request_timeout'),
4814                                        collection_formats=collection_formats)

Gets a list of permission profiles. Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str include:
Returns

PermissionProfileInformation If the method is called asynchronously, returns the request thread.

def list_recipient_names_by_email(self, account_id, **kwargs)
4816    def list_recipient_names_by_email(self, account_id, **kwargs):
4817        """
4818        Gets recipient names associated with an email address.
4819        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4820        This method makes a synchronous HTTP request by default. To make an
4821        asynchronous HTTP request, please define a `callback` function
4822        to be invoked when receiving the response.
4823        >>> def callback_function(response):
4824        >>>     pprint(response)
4825        >>>
4826        >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
4827
4828        :param callback function: The callback function
4829            for asynchronous request. (optional)
4830        :param str account_id: The external account number (int) or account ID Guid. (required)
4831        :param str email: The email address for the user
4832        :return: RecipientNamesResponse
4833                 If the method is called asynchronously,
4834                 returns the request thread.
4835        """
4836        kwargs['_return_http_data_only'] = True
4837        if kwargs.get('callback'):
4838            return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4839        else:
4840            (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs)
4841            return data

Gets recipient names associated with an email address. Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str email: The email address for the user
Returns

RecipientNamesResponse If the method is called asynchronously, returns the request thread.

def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs)
4843    def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs):
4844        """
4845        Gets recipient names associated with an email address.
4846        Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
4847        This method makes a synchronous HTTP request by default. To make an
4848        asynchronous HTTP request, please define a `callback` function
4849        to be invoked when receiving the response.
4850        >>> def callback_function(response):
4851        >>>     pprint(response)
4852        >>>
4853        >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
4854
4855        :param callback function: The callback function
4856            for asynchronous request. (optional)
4857        :param str account_id: The external account number (int) or account ID Guid. (required)
4858        :param str email: The email address for the user
4859        :return: RecipientNamesResponse
4860                 If the method is called asynchronously,
4861                 returns the request thread.
4862        """
4863
4864        all_params = ['account_id', 'email']
4865        all_params.append('callback')
4866        all_params.append('_return_http_data_only')
4867        all_params.append('_preload_content')
4868        all_params.append('_request_timeout')
4869
4870        params = locals()
4871        for key, val in iteritems(params['kwargs']):
4872            if key not in all_params:
4873                raise TypeError(
4874                    "Got an unexpected keyword argument '%s'"
4875                    " to method list_recipient_names_by_email" % key
4876                )
4877            params[key] = val
4878        del params['kwargs']
4879        # verify the required parameter 'account_id' is set
4880        if ('account_id' not in params) or (params['account_id'] is None):
4881            raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`")
4882
4883
4884        collection_formats = {}
4885
4886        resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json')
4887        path_params = {}
4888        if 'account_id' in params:
4889            path_params['accountId'] = params['account_id']
4890
4891        query_params = {}
4892        if 'email' in params:
4893            query_params['email'] = params['email']
4894
4895        header_params = {}
4896
4897        form_params = []
4898        local_var_files = {}
4899
4900        body_params = None
4901        # HTTP header `Accept`
4902        header_params['Accept'] = self.api_client.\
4903            select_header_accept(['application/json'])
4904
4905        # Authentication setting
4906        auth_settings = []
4907
4908        return self.api_client.call_api(resource_path, 'GET',
4909                                        path_params,
4910                                        query_params,
4911                                        header_params,
4912                                        body=body_params,
4913                                        post_params=form_params,
4914                                        files=local_var_files,
4915                                        response_type='RecipientNamesResponse',
4916                                        auth_settings=auth_settings,
4917                                        callback=params.get('callback'),
4918                                        _return_http_data_only=params.get('_return_http_data_only'),
4919                                        _preload_content=params.get('_preload_content', True),
4920                                        _request_timeout=params.get('_request_timeout'),
4921                                        collection_formats=collection_formats)

Gets recipient names associated with an email address. Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str email: The email address for the user
Returns

RecipientNamesResponse If the method is called asynchronously, returns the request thread.

def list_settings(self, account_id, **kwargs)
4923    def list_settings(self, account_id, **kwargs):
4924        """
4925        Gets account settings information.
4926        Retrieves the account settings information for the specified account.
4927        This method makes a synchronous HTTP request by default. To make an
4928        asynchronous HTTP request, please define a `callback` function
4929        to be invoked when receiving the response.
4930        >>> def callback_function(response):
4931        >>>     pprint(response)
4932        >>>
4933        >>> thread = api.list_settings(account_id, callback=callback_function)
4934
4935        :param callback function: The callback function
4936            for asynchronous request. (optional)
4937        :param str account_id: The external account number (int) or account ID Guid. (required)
4938        :return: AccountSettingsInformation
4939                 If the method is called asynchronously,
4940                 returns the request thread.
4941        """
4942        kwargs['_return_http_data_only'] = True
4943        if kwargs.get('callback'):
4944            return self.list_settings_with_http_info(account_id, **kwargs)
4945        else:
4946            (data) = self.list_settings_with_http_info(account_id, **kwargs)
4947            return data

Gets account settings information. Retrieves the account settings information for the specified account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_settings(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountSettingsInformation If the method is called asynchronously, returns the request thread.

def list_settings_with_http_info(self, account_id, **kwargs)
4949    def list_settings_with_http_info(self, account_id, **kwargs):
4950        """
4951        Gets account settings information.
4952        Retrieves the account settings information for the specified account.
4953        This method makes a synchronous HTTP request by default. To make an
4954        asynchronous HTTP request, please define a `callback` function
4955        to be invoked when receiving the response.
4956        >>> def callback_function(response):
4957        >>>     pprint(response)
4958        >>>
4959        >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function)
4960
4961        :param callback function: The callback function
4962            for asynchronous request. (optional)
4963        :param str account_id: The external account number (int) or account ID Guid. (required)
4964        :return: AccountSettingsInformation
4965                 If the method is called asynchronously,
4966                 returns the request thread.
4967        """
4968
4969        all_params = ['account_id']
4970        all_params.append('callback')
4971        all_params.append('_return_http_data_only')
4972        all_params.append('_preload_content')
4973        all_params.append('_request_timeout')
4974
4975        params = locals()
4976        for key, val in iteritems(params['kwargs']):
4977            if key not in all_params:
4978                raise TypeError(
4979                    "Got an unexpected keyword argument '%s'"
4980                    " to method list_settings" % key
4981                )
4982            params[key] = val
4983        del params['kwargs']
4984        # verify the required parameter 'account_id' is set
4985        if ('account_id' not in params) or (params['account_id'] is None):
4986            raise ValueError("Missing the required parameter `account_id` when calling `list_settings`")
4987
4988
4989        collection_formats = {}
4990
4991        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
4992        path_params = {}
4993        if 'account_id' in params:
4994            path_params['accountId'] = params['account_id']
4995
4996        query_params = {}
4997
4998        header_params = {}
4999
5000        form_params = []
5001        local_var_files = {}
5002
5003        body_params = None
5004        # HTTP header `Accept`
5005        header_params['Accept'] = self.api_client.\
5006            select_header_accept(['application/json'])
5007
5008        # Authentication setting
5009        auth_settings = []
5010
5011        return self.api_client.call_api(resource_path, 'GET',
5012                                        path_params,
5013                                        query_params,
5014                                        header_params,
5015                                        body=body_params,
5016                                        post_params=form_params,
5017                                        files=local_var_files,
5018                                        response_type='AccountSettingsInformation',
5019                                        auth_settings=auth_settings,
5020                                        callback=params.get('callback'),
5021                                        _return_http_data_only=params.get('_return_http_data_only'),
5022                                        _preload_content=params.get('_preload_content', True),
5023                                        _request_timeout=params.get('_request_timeout'),
5024                                        collection_formats=collection_formats)

Gets account settings information. Retrieves the account settings information for the specified account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_settings_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountSettingsInformation If the method is called asynchronously, returns the request thread.

def list_shared_access(self, account_id, **kwargs)
5026    def list_shared_access(self, account_id, **kwargs):
5027        """
5028        Reserved: Gets the shared item status for one or more users.
5029        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5030        This method makes a synchronous HTTP request by default. To make an
5031        asynchronous HTTP request, please define a `callback` function
5032        to be invoked when receiving the response.
5033        >>> def callback_function(response):
5034        >>>     pprint(response)
5035        >>>
5036        >>> thread = api.list_shared_access(account_id, callback=callback_function)
5037
5038        :param callback function: The callback function
5039            for asynchronous request. (optional)
5040        :param str account_id: The external account number (int) or account ID Guid. (required)
5041        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5042        :param str envelopes_not_shared_user_status:
5043        :param str folder_ids:
5044        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5045        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5046        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5047        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5048        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5049        :return: AccountSharedAccess
5050                 If the method is called asynchronously,
5051                 returns the request thread.
5052        """
5053        kwargs['_return_http_data_only'] = True
5054        if kwargs.get('callback'):
5055            return self.list_shared_access_with_http_info(account_id, **kwargs)
5056        else:
5057            (data) = self.list_shared_access_with_http_info(account_id, **kwargs)
5058            return data

Reserved: Gets the shared item status for one or more users. Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_shared_access(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
  • str envelopes_not_shared_user_status:
  • str folder_ids:
  • str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
  • str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
  • str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user
  • str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0.
  • str user_ids: A comma separated list of userIds for whom the shared item information is being requested.
Returns

AccountSharedAccess If the method is called asynchronously, returns the request thread.

def list_shared_access_with_http_info(self, account_id, **kwargs)
5060    def list_shared_access_with_http_info(self, account_id, **kwargs):
5061        """
5062        Reserved: Gets the shared item status for one or more users.
5063        Reserved: Retrieves shared item status for one or more users and types of items.  Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from.
5064        This method makes a synchronous HTTP request by default. To make an
5065        asynchronous HTTP request, please define a `callback` function
5066        to be invoked when receiving the response.
5067        >>> def callback_function(response):
5068        >>>     pprint(response)
5069        >>>
5070        >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function)
5071
5072        :param callback function: The callback function
5073            for asynchronous request. (optional)
5074        :param str account_id: The external account number (int) or account ID Guid. (required)
5075        :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
5076        :param str envelopes_not_shared_user_status:
5077        :param str folder_ids:
5078        :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
5079        :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
5080        :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are:  -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user.  User X (Share) X Account user  -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user).  User X (Share) Account user  -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user).  User (Share) >> Account user  -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user.  User << (Share) >> Account user
5081        :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 
5082        :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 
5083        :return: AccountSharedAccess
5084                 If the method is called asynchronously,
5085                 returns the request thread.
5086        """
5087
5088        all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids']
5089        all_params.append('callback')
5090        all_params.append('_return_http_data_only')
5091        all_params.append('_preload_content')
5092        all_params.append('_request_timeout')
5093
5094        params = locals()
5095        for key, val in iteritems(params['kwargs']):
5096            if key not in all_params:
5097                raise TypeError(
5098                    "Got an unexpected keyword argument '%s'"
5099                    " to method list_shared_access" % key
5100                )
5101            params[key] = val
5102        del params['kwargs']
5103        # verify the required parameter 'account_id' is set
5104        if ('account_id' not in params) or (params['account_id'] is None):
5105            raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`")
5106
5107
5108        collection_formats = {}
5109
5110        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
5111        path_params = {}
5112        if 'account_id' in params:
5113            path_params['accountId'] = params['account_id']
5114
5115        query_params = {}
5116        if 'count' in params:
5117            query_params['count'] = params['count']
5118        if 'envelopes_not_shared_user_status' in params:
5119            query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status']
5120        if 'folder_ids' in params:
5121            query_params['folder_ids'] = params['folder_ids']
5122        if 'item_type' in params:
5123            query_params['item_type'] = params['item_type']
5124        if 'search_text' in params:
5125            query_params['search_text'] = params['search_text']
5126        if 'shared' in params:
5127            query_params['shared'] = params['shared']
5128        if 'start_position' in params:
5129            query_params['start_position'] = params['start_position']
5130        if 'user_ids' in params:
5131            query_params['user_ids'] = params['user_ids']
5132
5133        header_params = {}
5134
5135        form_params = []
5136        local_var_files = {}
5137
5138        body_params = None
5139        # HTTP header `Accept`
5140        header_params['Accept'] = self.api_client.\
5141            select_header_accept(['application/json'])
5142
5143        # Authentication setting
5144        auth_settings = []
5145
5146        return self.api_client.call_api(resource_path, 'GET',
5147                                        path_params,
5148                                        query_params,
5149                                        header_params,
5150                                        body=body_params,
5151                                        post_params=form_params,
5152                                        files=local_var_files,
5153                                        response_type='AccountSharedAccess',
5154                                        auth_settings=auth_settings,
5155                                        callback=params.get('callback'),
5156                                        _return_http_data_only=params.get('_return_http_data_only'),
5157                                        _preload_content=params.get('_preload_content', True),
5158                                        _request_timeout=params.get('_request_timeout'),
5159                                        collection_formats=collection_formats)

Reserved: Gets the shared item status for one or more users. Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000.
  • str envelopes_not_shared_user_status:
  • str folder_ids:
  • str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users.
  • str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string.
  • str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user
  • str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0.
  • str user_ids: A comma separated list of userIds for whom the shared item information is being requested.
Returns

AccountSharedAccess If the method is called asynchronously, returns the request thread.

def list_signature_providers(self, account_id, **kwargs)
5161    def list_signature_providers(self, account_id, **kwargs):
5162        """
5163        Returns Account available signature providers for specified account.
5164        Returns a list of signature providers that the specified account can use.
5165        This method makes a synchronous HTTP request by default. To make an
5166        asynchronous HTTP request, please define a `callback` function
5167        to be invoked when receiving the response.
5168        >>> def callback_function(response):
5169        >>>     pprint(response)
5170        >>>
5171        >>> thread = api.list_signature_providers(account_id, callback=callback_function)
5172
5173        :param callback function: The callback function
5174            for asynchronous request. (optional)
5175        :param str account_id: The external account number (int) or account ID Guid. (required)
5176        :return: AccountSignatureProviders
5177                 If the method is called asynchronously,
5178                 returns the request thread.
5179        """
5180        kwargs['_return_http_data_only'] = True
5181        if kwargs.get('callback'):
5182            return self.list_signature_providers_with_http_info(account_id, **kwargs)
5183        else:
5184            (data) = self.list_signature_providers_with_http_info(account_id, **kwargs)
5185            return data

Returns Account available signature providers for specified account. Returns a list of signature providers that the specified account can use. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_signature_providers(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountSignatureProviders If the method is called asynchronously, returns the request thread.

def list_signature_providers_with_http_info(self, account_id, **kwargs)
5187    def list_signature_providers_with_http_info(self, account_id, **kwargs):
5188        """
5189        Returns Account available signature providers for specified account.
5190        Returns a list of signature providers that the specified account can use.
5191        This method makes a synchronous HTTP request by default. To make an
5192        asynchronous HTTP request, please define a `callback` function
5193        to be invoked when receiving the response.
5194        >>> def callback_function(response):
5195        >>>     pprint(response)
5196        >>>
5197        >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function)
5198
5199        :param callback function: The callback function
5200            for asynchronous request. (optional)
5201        :param str account_id: The external account number (int) or account ID Guid. (required)
5202        :return: AccountSignatureProviders
5203                 If the method is called asynchronously,
5204                 returns the request thread.
5205        """
5206
5207        all_params = ['account_id']
5208        all_params.append('callback')
5209        all_params.append('_return_http_data_only')
5210        all_params.append('_preload_content')
5211        all_params.append('_request_timeout')
5212
5213        params = locals()
5214        for key, val in iteritems(params['kwargs']):
5215            if key not in all_params:
5216                raise TypeError(
5217                    "Got an unexpected keyword argument '%s'"
5218                    " to method list_signature_providers" % key
5219                )
5220            params[key] = val
5221        del params['kwargs']
5222        # verify the required parameter 'account_id' is set
5223        if ('account_id' not in params) or (params['account_id'] is None):
5224            raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`")
5225
5226
5227        collection_formats = {}
5228
5229        resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json')
5230        path_params = {}
5231        if 'account_id' in params:
5232            path_params['accountId'] = params['account_id']
5233
5234        query_params = {}
5235
5236        header_params = {}
5237
5238        form_params = []
5239        local_var_files = {}
5240
5241        body_params = None
5242        # HTTP header `Accept`
5243        header_params['Accept'] = self.api_client.\
5244            select_header_accept(['application/json'])
5245
5246        # Authentication setting
5247        auth_settings = []
5248
5249        return self.api_client.call_api(resource_path, 'GET',
5250                                        path_params,
5251                                        query_params,
5252                                        header_params,
5253                                        body=body_params,
5254                                        post_params=form_params,
5255                                        files=local_var_files,
5256                                        response_type='AccountSignatureProviders',
5257                                        auth_settings=auth_settings,
5258                                        callback=params.get('callback'),
5259                                        _return_http_data_only=params.get('_return_http_data_only'),
5260                                        _preload_content=params.get('_preload_content', True),
5261                                        _request_timeout=params.get('_request_timeout'),
5262                                        collection_formats=collection_formats)

Returns Account available signature providers for specified account. Returns a list of signature providers that the specified account can use. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

AccountSignatureProviders If the method is called asynchronously, returns the request thread.

def list_unsupported_file_types(self, account_id, **kwargs)
5264    def list_unsupported_file_types(self, account_id, **kwargs):
5265        """
5266        Gets a list of unsupported file types.
5267        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5268        This method makes a synchronous HTTP request by default. To make an
5269        asynchronous HTTP request, please define a `callback` function
5270        to be invoked when receiving the response.
5271        >>> def callback_function(response):
5272        >>>     pprint(response)
5273        >>>
5274        >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function)
5275
5276        :param callback function: The callback function
5277            for asynchronous request. (optional)
5278        :param str account_id: The external account number (int) or account ID Guid. (required)
5279        :return: FileTypeList
5280                 If the method is called asynchronously,
5281                 returns the request thread.
5282        """
5283        kwargs['_return_http_data_only'] = True
5284        if kwargs.get('callback'):
5285            return self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5286        else:
5287            (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs)
5288            return data

Gets a list of unsupported file types. Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_unsupported_file_types(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

FileTypeList If the method is called asynchronously, returns the request thread.

def list_unsupported_file_types_with_http_info(self, account_id, **kwargs)
5290    def list_unsupported_file_types_with_http_info(self, account_id, **kwargs):
5291        """
5292        Gets a list of unsupported file types.
5293        Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
5294        This method makes a synchronous HTTP request by default. To make an
5295        asynchronous HTTP request, please define a `callback` function
5296        to be invoked when receiving the response.
5297        >>> def callback_function(response):
5298        >>>     pprint(response)
5299        >>>
5300        >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function)
5301
5302        :param callback function: The callback function
5303            for asynchronous request. (optional)
5304        :param str account_id: The external account number (int) or account ID Guid. (required)
5305        :return: FileTypeList
5306                 If the method is called asynchronously,
5307                 returns the request thread.
5308        """
5309
5310        all_params = ['account_id']
5311        all_params.append('callback')
5312        all_params.append('_return_http_data_only')
5313        all_params.append('_preload_content')
5314        all_params.append('_request_timeout')
5315
5316        params = locals()
5317        for key, val in iteritems(params['kwargs']):
5318            if key not in all_params:
5319                raise TypeError(
5320                    "Got an unexpected keyword argument '%s'"
5321                    " to method list_unsupported_file_types" % key
5322                )
5323            params[key] = val
5324        del params['kwargs']
5325        # verify the required parameter 'account_id' is set
5326        if ('account_id' not in params) or (params['account_id'] is None):
5327            raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`")
5328
5329
5330        collection_formats = {}
5331
5332        resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json')
5333        path_params = {}
5334        if 'account_id' in params:
5335            path_params['accountId'] = params['account_id']
5336
5337        query_params = {}
5338
5339        header_params = {}
5340
5341        form_params = []
5342        local_var_files = {}
5343
5344        body_params = None
5345        # HTTP header `Accept`
5346        header_params['Accept'] = self.api_client.\
5347            select_header_accept(['application/json'])
5348
5349        # Authentication setting
5350        auth_settings = []
5351
5352        return self.api_client.call_api(resource_path, 'GET',
5353                                        path_params,
5354                                        query_params,
5355                                        header_params,
5356                                        body=body_params,
5357                                        post_params=form_params,
5358                                        files=local_var_files,
5359                                        response_type='FileTypeList',
5360                                        auth_settings=auth_settings,
5361                                        callback=params.get('callback'),
5362                                        _return_http_data_only=params.get('_return_http_data_only'),
5363                                        _preload_content=params.get('_preload_content', True),
5364                                        _request_timeout=params.get('_request_timeout'),
5365                                        collection_formats=collection_formats)

Gets a list of unsupported file types. Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
Returns

FileTypeList If the method is called asynchronously, returns the request thread.

def un_favorite_template(self, account_id, **kwargs)
5367    def un_favorite_template(self, account_id, **kwargs):
5368        """
5369        Unfavorite a template
5370        
5371        This method makes a synchronous HTTP request by default. To make an
5372        asynchronous HTTP request, please define a `callback` function
5373        to be invoked when receiving the response.
5374        >>> def callback_function(response):
5375        >>>     pprint(response)
5376        >>>
5377        >>> thread = api.un_favorite_template(account_id, callback=callback_function)
5378
5379        :param callback function: The callback function
5380            for asynchronous request. (optional)
5381        :param str account_id: The external account number (int) or account ID Guid. (required)
5382        :param FavoriteTemplatesInfo favorite_templates_info:
5383        :return: FavoriteTemplatesInfo
5384                 If the method is called asynchronously,
5385                 returns the request thread.
5386        """
5387        kwargs['_return_http_data_only'] = True
5388        if kwargs.get('callback'):
5389            return self.un_favorite_template_with_http_info(account_id, **kwargs)
5390        else:
5391            (data) = self.un_favorite_template_with_http_info(account_id, **kwargs)
5392            return data

Unfavorite a template

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.un_favorite_template(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • FavoriteTemplatesInfo favorite_templates_info:
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def un_favorite_template_with_http_info(self, account_id, **kwargs)
5394    def un_favorite_template_with_http_info(self, account_id, **kwargs):
5395        """
5396        Unfavorite a template
5397        
5398        This method makes a synchronous HTTP request by default. To make an
5399        asynchronous HTTP request, please define a `callback` function
5400        to be invoked when receiving the response.
5401        >>> def callback_function(response):
5402        >>>     pprint(response)
5403        >>>
5404        >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function)
5405
5406        :param callback function: The callback function
5407            for asynchronous request. (optional)
5408        :param str account_id: The external account number (int) or account ID Guid. (required)
5409        :param FavoriteTemplatesInfo favorite_templates_info:
5410        :return: FavoriteTemplatesInfo
5411                 If the method is called asynchronously,
5412                 returns the request thread.
5413        """
5414
5415        all_params = ['account_id', 'favorite_templates_info']
5416        all_params.append('callback')
5417        all_params.append('_return_http_data_only')
5418        all_params.append('_preload_content')
5419        all_params.append('_request_timeout')
5420
5421        params = locals()
5422        for key, val in iteritems(params['kwargs']):
5423            if key not in all_params:
5424                raise TypeError(
5425                    "Got an unexpected keyword argument '%s'"
5426                    " to method un_favorite_template" % key
5427                )
5428            params[key] = val
5429        del params['kwargs']
5430        # verify the required parameter 'account_id' is set
5431        if ('account_id' not in params) or (params['account_id'] is None):
5432            raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`")
5433
5434
5435        collection_formats = {}
5436
5437        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
5438        path_params = {}
5439        if 'account_id' in params:
5440            path_params['accountId'] = params['account_id']
5441
5442        query_params = {}
5443
5444        header_params = {}
5445
5446        form_params = []
5447        local_var_files = {}
5448
5449        body_params = None
5450        if 'favorite_templates_info' in params:
5451            body_params = params['favorite_templates_info']
5452        # HTTP header `Accept`
5453        header_params['Accept'] = self.api_client.\
5454            select_header_accept(['application/json'])
5455
5456        # Authentication setting
5457        auth_settings = []
5458
5459        return self.api_client.call_api(resource_path, 'DELETE',
5460                                        path_params,
5461                                        query_params,
5462                                        header_params,
5463                                        body=body_params,
5464                                        post_params=form_params,
5465                                        files=local_var_files,
5466                                        response_type='FavoriteTemplatesInfo',
5467                                        auth_settings=auth_settings,
5468                                        callback=params.get('callback'),
5469                                        _return_http_data_only=params.get('_return_http_data_only'),
5470                                        _preload_content=params.get('_preload_content', True),
5471                                        _request_timeout=params.get('_request_timeout'),
5472                                        collection_formats=collection_formats)

Unfavorite a template

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • FavoriteTemplatesInfo favorite_templates_info:
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def update_account_signature(self, account_id, **kwargs)
5474    def update_account_signature(self, account_id, **kwargs):
5475        """
5476        Updates a account signature.
5477        
5478        This method makes a synchronous HTTP request by default. To make an
5479        asynchronous HTTP request, please define a `callback` function
5480        to be invoked when receiving the response.
5481        >>> def callback_function(response):
5482        >>>     pprint(response)
5483        >>>
5484        >>> thread = api.update_account_signature(account_id, callback=callback_function)
5485
5486        :param callback function: The callback function
5487            for asynchronous request. (optional)
5488        :param str account_id: The external account number (int) or account ID Guid. (required)
5489        :param AccountSignaturesInformation account_signatures_information:
5490        :return: AccountSignaturesInformation
5491                 If the method is called asynchronously,
5492                 returns the request thread.
5493        """
5494        kwargs['_return_http_data_only'] = True
5495        if kwargs.get('callback'):
5496            return self.update_account_signature_with_http_info(account_id, **kwargs)
5497        else:
5498            (data) = self.update_account_signature_with_http_info(account_id, **kwargs)
5499            return data

Updates a account signature.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountSignaturesInformation account_signatures_information:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def update_account_signature_with_http_info(self, account_id, **kwargs)
5501    def update_account_signature_with_http_info(self, account_id, **kwargs):
5502        """
5503        Updates a account signature.
5504        
5505        This method makes a synchronous HTTP request by default. To make an
5506        asynchronous HTTP request, please define a `callback` function
5507        to be invoked when receiving the response.
5508        >>> def callback_function(response):
5509        >>>     pprint(response)
5510        >>>
5511        >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function)
5512
5513        :param callback function: The callback function
5514            for asynchronous request. (optional)
5515        :param str account_id: The external account number (int) or account ID Guid. (required)
5516        :param AccountSignaturesInformation account_signatures_information:
5517        :return: AccountSignaturesInformation
5518                 If the method is called asynchronously,
5519                 returns the request thread.
5520        """
5521
5522        all_params = ['account_id', 'account_signatures_information']
5523        all_params.append('callback')
5524        all_params.append('_return_http_data_only')
5525        all_params.append('_preload_content')
5526        all_params.append('_request_timeout')
5527
5528        params = locals()
5529        for key, val in iteritems(params['kwargs']):
5530            if key not in all_params:
5531                raise TypeError(
5532                    "Got an unexpected keyword argument '%s'"
5533                    " to method update_account_signature" % key
5534                )
5535            params[key] = val
5536        del params['kwargs']
5537        # verify the required parameter 'account_id' is set
5538        if ('account_id' not in params) or (params['account_id'] is None):
5539            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`")
5540
5541
5542        collection_formats = {}
5543
5544        resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json')
5545        path_params = {}
5546        if 'account_id' in params:
5547            path_params['accountId'] = params['account_id']
5548
5549        query_params = {}
5550
5551        header_params = {}
5552
5553        form_params = []
5554        local_var_files = {}
5555
5556        body_params = None
5557        if 'account_signatures_information' in params:
5558            body_params = params['account_signatures_information']
5559        # HTTP header `Accept`
5560        header_params['Accept'] = self.api_client.\
5561            select_header_accept(['application/json'])
5562
5563        # Authentication setting
5564        auth_settings = []
5565
5566        return self.api_client.call_api(resource_path, 'PUT',
5567                                        path_params,
5568                                        query_params,
5569                                        header_params,
5570                                        body=body_params,
5571                                        post_params=form_params,
5572                                        files=local_var_files,
5573                                        response_type='AccountSignaturesInformation',
5574                                        auth_settings=auth_settings,
5575                                        callback=params.get('callback'),
5576                                        _return_http_data_only=params.get('_return_http_data_only'),
5577                                        _preload_content=params.get('_preload_content', True),
5578                                        _request_timeout=params.get('_request_timeout'),
5579                                        collection_formats=collection_formats)

Updates a account signature.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountSignaturesInformation account_signatures_information:
Returns

AccountSignaturesInformation If the method is called asynchronously, returns the request thread.

def update_account_signature_by_id(self, account_id, signature_id, **kwargs)
5581    def update_account_signature_by_id(self, account_id, signature_id, **kwargs):
5582        """
5583        Updates a account signature.
5584        
5585        This method makes a synchronous HTTP request by default. To make an
5586        asynchronous HTTP request, please define a `callback` function
5587        to be invoked when receiving the response.
5588        >>> def callback_function(response):
5589        >>>     pprint(response)
5590        >>>
5591        >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function)
5592
5593        :param callback function: The callback function
5594            for asynchronous request. (optional)
5595        :param str account_id: The external account number (int) or account ID Guid. (required)
5596        :param str signature_id: The ID of the signature being accessed. (required)
5597        :param str close_existing_signature:
5598        :param AccountSignatureDefinition account_signature_definition:
5599        :return: AccountSignature
5600                 If the method is called asynchronously,
5601                 returns the request thread.
5602        """
5603        kwargs['_return_http_data_only'] = True
5604        if kwargs.get('callback'):
5605            return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5606        else:
5607            (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs)
5608            return data

Updates a account signature.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str close_existing_signature:
  • AccountSignatureDefinition account_signature_definition:
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs)
5610    def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs):
5611        """
5612        Updates a account signature.
5613        
5614        This method makes a synchronous HTTP request by default. To make an
5615        asynchronous HTTP request, please define a `callback` function
5616        to be invoked when receiving the response.
5617        >>> def callback_function(response):
5618        >>>     pprint(response)
5619        >>>
5620        >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
5621
5622        :param callback function: The callback function
5623            for asynchronous request. (optional)
5624        :param str account_id: The external account number (int) or account ID Guid. (required)
5625        :param str signature_id: The ID of the signature being accessed. (required)
5626        :param str close_existing_signature:
5627        :param AccountSignatureDefinition account_signature_definition:
5628        :return: AccountSignature
5629                 If the method is called asynchronously,
5630                 returns the request thread.
5631        """
5632
5633        all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition']
5634        all_params.append('callback')
5635        all_params.append('_return_http_data_only')
5636        all_params.append('_preload_content')
5637        all_params.append('_request_timeout')
5638
5639        params = locals()
5640        for key, val in iteritems(params['kwargs']):
5641            if key not in all_params:
5642                raise TypeError(
5643                    "Got an unexpected keyword argument '%s'"
5644                    " to method update_account_signature_by_id" % key
5645                )
5646            params[key] = val
5647        del params['kwargs']
5648        # verify the required parameter 'account_id' is set
5649        if ('account_id' not in params) or (params['account_id'] is None):
5650            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`")
5651        # verify the required parameter 'signature_id' is set
5652        if ('signature_id' not in params) or (params['signature_id'] is None):
5653            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`")
5654
5655
5656        collection_formats = {}
5657
5658        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json')
5659        path_params = {}
5660        if 'account_id' in params:
5661            path_params['accountId'] = params['account_id']
5662        if 'signature_id' in params:
5663            path_params['signatureId'] = params['signature_id']
5664
5665        query_params = {}
5666        if 'close_existing_signature' in params:
5667            query_params['close_existing_signature'] = params['close_existing_signature']
5668
5669        header_params = {}
5670
5671        form_params = []
5672        local_var_files = {}
5673
5674        body_params = None
5675        if 'account_signature_definition' in params:
5676            body_params = params['account_signature_definition']
5677        # HTTP header `Accept`
5678        header_params['Accept'] = self.api_client.\
5679            select_header_accept(['application/json'])
5680
5681        # Authentication setting
5682        auth_settings = []
5683
5684        return self.api_client.call_api(resource_path, 'PUT',
5685                                        path_params,
5686                                        query_params,
5687                                        header_params,
5688                                        body=body_params,
5689                                        post_params=form_params,
5690                                        files=local_var_files,
5691                                        response_type='AccountSignature',
5692                                        auth_settings=auth_settings,
5693                                        callback=params.get('callback'),
5694                                        _return_http_data_only=params.get('_return_http_data_only'),
5695                                        _preload_content=params.get('_preload_content', True),
5696                                        _request_timeout=params.get('_request_timeout'),
5697                                        collection_formats=collection_formats)

Updates a account signature.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str close_existing_signature:
  • AccountSignatureDefinition account_signature_definition:
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
5699    def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs):
5700        """
5701        Sets a signature, initials, or stamps image.
5702        
5703        This method makes a synchronous HTTP request by default. To make an
5704        asynchronous HTTP request, please define a `callback` function
5705        to be invoked when receiving the response.
5706        >>> def callback_function(response):
5707        >>>     pprint(response)
5708        >>>
5709        >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
5710
5711        :param callback function: The callback function
5712            for asynchronous request. (optional)
5713        :param str account_id: The external account number (int) or account ID Guid. (required)
5714        :param str image_type: One of **signature_image** or **initials_image**. (required)
5715        :param str signature_id: The ID of the signature being accessed. (required)
5716        :param str transparent_png:
5717        :return: AccountSignature
5718                 If the method is called asynchronously,
5719                 returns the request thread.
5720        """
5721        kwargs['_return_http_data_only'] = True
5722        if kwargs.get('callback'):
5723            return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5724        else:
5725            (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs)
5726            return data

Sets a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str transparent_png:
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
5728    def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs):
5729        """
5730        Sets a signature, initials, or stamps image.
5731        
5732        This method makes a synchronous HTTP request by default. To make an
5733        asynchronous HTTP request, please define a `callback` function
5734        to be invoked when receiving the response.
5735        >>> def callback_function(response):
5736        >>>     pprint(response)
5737        >>>
5738        >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
5739
5740        :param callback function: The callback function
5741            for asynchronous request. (optional)
5742        :param str account_id: The external account number (int) or account ID Guid. (required)
5743        :param str image_type: One of **signature_image** or **initials_image**. (required)
5744        :param str signature_id: The ID of the signature being accessed. (required)
5745        :param str transparent_png:
5746        :return: AccountSignature
5747                 If the method is called asynchronously,
5748                 returns the request thread.
5749        """
5750
5751        all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png']
5752        all_params.append('callback')
5753        all_params.append('_return_http_data_only')
5754        all_params.append('_preload_content')
5755        all_params.append('_request_timeout')
5756
5757        params = locals()
5758        for key, val in iteritems(params['kwargs']):
5759            if key not in all_params:
5760                raise TypeError(
5761                    "Got an unexpected keyword argument '%s'"
5762                    " to method update_account_signature_image" % key
5763                )
5764            params[key] = val
5765        del params['kwargs']
5766        # verify the required parameter 'account_id' is set
5767        if ('account_id' not in params) or (params['account_id'] is None):
5768            raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`")
5769        # verify the required parameter 'image_type' is set
5770        if ('image_type' not in params) or (params['image_type'] is None):
5771            raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`")
5772        # verify the required parameter 'signature_id' is set
5773        if ('signature_id' not in params) or (params['signature_id'] is None):
5774            raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`")
5775
5776
5777        collection_formats = {}
5778
5779        resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json')
5780        path_params = {}
5781        if 'account_id' in params:
5782            path_params['accountId'] = params['account_id']
5783        if 'image_type' in params:
5784            path_params['imageType'] = params['image_type']
5785        if 'signature_id' in params:
5786            path_params['signatureId'] = params['signature_id']
5787
5788        query_params = {}
5789        if 'transparent_png' in params:
5790            query_params['transparent_png'] = params['transparent_png']
5791
5792        header_params = {}
5793
5794        form_params = []
5795        local_var_files = {}
5796
5797        body_params = None
5798        # HTTP header `Accept`
5799        header_params['Accept'] = self.api_client.\
5800            select_header_accept(['application/json'])
5801
5802        # HTTP header `Content-Type`
5803        header_params['Content-Type'] = self.api_client.\
5804            select_header_content_type(['image/gif'])
5805
5806        # Authentication setting
5807        auth_settings = []
5808
5809        return self.api_client.call_api(resource_path, 'PUT',
5810                                        path_params,
5811                                        query_params,
5812                                        header_params,
5813                                        body=body_params,
5814                                        post_params=form_params,
5815                                        files=local_var_files,
5816                                        response_type='AccountSignature',
5817                                        auth_settings=auth_settings,
5818                                        callback=params.get('callback'),
5819                                        _return_http_data_only=params.get('_return_http_data_only'),
5820                                        _preload_content=params.get('_preload_content', True),
5821                                        _request_timeout=params.get('_request_timeout'),
5822                                        collection_formats=collection_formats)

Sets a signature, initials, or stamps image.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str image_type: One of signature_image or initials_image. (required)
  • str signature_id: The ID of the signature being accessed. (required)
  • str transparent_png:
Returns

AccountSignature If the method is called asynchronously, returns the request thread.

def update_account_tab_settings(self, account_id, **kwargs)
5824    def update_account_tab_settings(self, account_id, **kwargs):
5825        """
5826        Modifies tab settings for specified account
5827        This method modifies the tab types and tab functionality that is enabled for an account.
5828        This method makes a synchronous HTTP request by default. To make an
5829        asynchronous HTTP request, please define a `callback` function
5830        to be invoked when receiving the response.
5831        >>> def callback_function(response):
5832        >>>     pprint(response)
5833        >>>
5834        >>> thread = api.update_account_tab_settings(account_id, callback=callback_function)
5835
5836        :param callback function: The callback function
5837            for asynchronous request. (optional)
5838        :param str account_id: The external account number (int) or account ID Guid. (required)
5839        :param TabAccountSettings tab_account_settings:
5840        :return: TabAccountSettings
5841                 If the method is called asynchronously,
5842                 returns the request thread.
5843        """
5844        kwargs['_return_http_data_only'] = True
5845        if kwargs.get('callback'):
5846            return self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5847        else:
5848            (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs)
5849            return data

Modifies tab settings for specified account This method modifies the tab types and tab functionality that is enabled for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_tab_settings(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • TabAccountSettings tab_account_settings:
Returns

TabAccountSettings If the method is called asynchronously, returns the request thread.

def update_account_tab_settings_with_http_info(self, account_id, **kwargs)
5851    def update_account_tab_settings_with_http_info(self, account_id, **kwargs):
5852        """
5853        Modifies tab settings for specified account
5854        This method modifies the tab types and tab functionality that is enabled for an account.
5855        This method makes a synchronous HTTP request by default. To make an
5856        asynchronous HTTP request, please define a `callback` function
5857        to be invoked when receiving the response.
5858        >>> def callback_function(response):
5859        >>>     pprint(response)
5860        >>>
5861        >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function)
5862
5863        :param callback function: The callback function
5864            for asynchronous request. (optional)
5865        :param str account_id: The external account number (int) or account ID Guid. (required)
5866        :param TabAccountSettings tab_account_settings:
5867        :return: TabAccountSettings
5868                 If the method is called asynchronously,
5869                 returns the request thread.
5870        """
5871
5872        all_params = ['account_id', 'tab_account_settings']
5873        all_params.append('callback')
5874        all_params.append('_return_http_data_only')
5875        all_params.append('_preload_content')
5876        all_params.append('_request_timeout')
5877
5878        params = locals()
5879        for key, val in iteritems(params['kwargs']):
5880            if key not in all_params:
5881                raise TypeError(
5882                    "Got an unexpected keyword argument '%s'"
5883                    " to method update_account_tab_settings" % key
5884                )
5885            params[key] = val
5886        del params['kwargs']
5887        # verify the required parameter 'account_id' is set
5888        if ('account_id' not in params) or (params['account_id'] is None):
5889            raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`")
5890
5891
5892        collection_formats = {}
5893
5894        resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json')
5895        path_params = {}
5896        if 'account_id' in params:
5897            path_params['accountId'] = params['account_id']
5898
5899        query_params = {}
5900
5901        header_params = {}
5902
5903        form_params = []
5904        local_var_files = {}
5905
5906        body_params = None
5907        if 'tab_account_settings' in params:
5908            body_params = params['tab_account_settings']
5909        # HTTP header `Accept`
5910        header_params['Accept'] = self.api_client.\
5911            select_header_accept(['application/json'])
5912
5913        # Authentication setting
5914        auth_settings = []
5915
5916        return self.api_client.call_api(resource_path, 'PUT',
5917                                        path_params,
5918                                        query_params,
5919                                        header_params,
5920                                        body=body_params,
5921                                        post_params=form_params,
5922                                        files=local_var_files,
5923                                        response_type='TabAccountSettings',
5924                                        auth_settings=auth_settings,
5925                                        callback=params.get('callback'),
5926                                        _return_http_data_only=params.get('_return_http_data_only'),
5927                                        _preload_content=params.get('_preload_content', True),
5928                                        _request_timeout=params.get('_request_timeout'),
5929                                        collection_formats=collection_formats)

Modifies tab settings for specified account This method modifies the tab types and tab functionality that is enabled for an account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • TabAccountSettings tab_account_settings:
Returns

TabAccountSettings If the method is called asynchronously, returns the request thread.

def update_brand(self, account_id, brand_id, **kwargs)
5931    def update_brand(self, account_id, brand_id, **kwargs):
5932        """
5933        Updates an existing brand.
5934        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5935        This method makes a synchronous HTTP request by default. To make an
5936        asynchronous HTTP request, please define a `callback` function
5937        to be invoked when receiving the response.
5938        >>> def callback_function(response):
5939        >>>     pprint(response)
5940        >>>
5941        >>> thread = api.update_brand(account_id, brand_id, callback=callback_function)
5942
5943        :param callback function: The callback function
5944            for asynchronous request. (optional)
5945        :param str account_id: The external account number (int) or account ID Guid. (required)
5946        :param str brand_id: The unique identifier of a brand. (required)
5947        :param str replace_brand:
5948        :param Brand brand:
5949        :return: Brand
5950                 If the method is called asynchronously,
5951                 returns the request thread.
5952        """
5953        kwargs['_return_http_data_only'] = True
5954        if kwargs.get('callback'):
5955            return self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5956        else:
5957            (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs)
5958            return data

Updates an existing brand. This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str replace_brand:
  • Brand brand:
Returns

Brand If the method is called asynchronously, returns the request thread.

def update_brand_with_http_info(self, account_id, brand_id, **kwargs)
5960    def update_brand_with_http_info(self, account_id, brand_id, **kwargs):
5961        """
5962        Updates an existing brand.
5963        This method updates an account brand.   **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
5964        This method makes a synchronous HTTP request by default. To make an
5965        asynchronous HTTP request, please define a `callback` function
5966        to be invoked when receiving the response.
5967        >>> def callback_function(response):
5968        >>>     pprint(response)
5969        >>>
5970        >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
5971
5972        :param callback function: The callback function
5973            for asynchronous request. (optional)
5974        :param str account_id: The external account number (int) or account ID Guid. (required)
5975        :param str brand_id: The unique identifier of a brand. (required)
5976        :param str replace_brand:
5977        :param Brand brand:
5978        :return: Brand
5979                 If the method is called asynchronously,
5980                 returns the request thread.
5981        """
5982
5983        all_params = ['account_id', 'brand_id', 'replace_brand', 'brand']
5984        all_params.append('callback')
5985        all_params.append('_return_http_data_only')
5986        all_params.append('_preload_content')
5987        all_params.append('_request_timeout')
5988
5989        params = locals()
5990        for key, val in iteritems(params['kwargs']):
5991            if key not in all_params:
5992                raise TypeError(
5993                    "Got an unexpected keyword argument '%s'"
5994                    " to method update_brand" % key
5995                )
5996            params[key] = val
5997        del params['kwargs']
5998        # verify the required parameter 'account_id' is set
5999        if ('account_id' not in params) or (params['account_id'] is None):
6000            raise ValueError("Missing the required parameter `account_id` when calling `update_brand`")
6001        # verify the required parameter 'brand_id' is set
6002        if ('brand_id' not in params) or (params['brand_id'] is None):
6003            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`")
6004
6005
6006        collection_formats = {}
6007
6008        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json')
6009        path_params = {}
6010        if 'account_id' in params:
6011            path_params['accountId'] = params['account_id']
6012        if 'brand_id' in params:
6013            path_params['brandId'] = params['brand_id']
6014
6015        query_params = {}
6016        if 'replace_brand' in params:
6017            query_params['replace_brand'] = params['replace_brand']
6018
6019        header_params = {}
6020
6021        form_params = []
6022        local_var_files = {}
6023
6024        body_params = None
6025        if 'brand' in params:
6026            body_params = params['brand']
6027        # HTTP header `Accept`
6028        header_params['Accept'] = self.api_client.\
6029            select_header_accept(['application/json'])
6030
6031        # Authentication setting
6032        auth_settings = []
6033
6034        return self.api_client.call_api(resource_path, 'PUT',
6035                                        path_params,
6036                                        query_params,
6037                                        header_params,
6038                                        body=body_params,
6039                                        post_params=form_params,
6040                                        files=local_var_files,
6041                                        response_type='Brand',
6042                                        auth_settings=auth_settings,
6043                                        callback=params.get('callback'),
6044                                        _return_http_data_only=params.get('_return_http_data_only'),
6045                                        _preload_content=params.get('_preload_content', True),
6046                                        _request_timeout=params.get('_request_timeout'),
6047                                        collection_formats=collection_formats)

Updates an existing brand. This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str brand_id: The unique identifier of a brand. (required)
  • str replace_brand:
  • Brand brand:
Returns

Brand If the method is called asynchronously, returns the request thread.

def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6049    def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6050        """
6051        Put one branding logo.
6052        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6053        This method makes a synchronous HTTP request by default. To make an
6054        asynchronous HTTP request, please define a `callback` function
6055        to be invoked when receiving the response.
6056        >>> def callback_function(response):
6057        >>>     pprint(response)
6058        >>>
6059        >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6060
6061        :param callback function: The callback function
6062            for asynchronous request. (optional)
6063        :param str account_id: The external account number (int) or account ID GUID. (required)
6064        :param str brand_id: The ID of the brand. (required)
6065        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6066        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6067        :return: None
6068                 If the method is called asynchronously,
6069                 returns the request thread.
6070        """
6071        kwargs['_return_http_data_only'] = True
6072        if kwargs.get('callback'):
6073            return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6074        else:
6075            (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6076            return data

Put one branding logo. This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • str brand_id: The ID of the brand. (required)
  • str logo_type: The type of logo. Valid values are: - primary - secondary - email (required)
  • str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns

None If the method is called asynchronously, returns the request thread.

def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6078    def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs):
6079        """
6080        Put one branding logo.
6081        This method updates a single brand logo.  You pass in the new version of the resource in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).
6082        This method makes a synchronous HTTP request by default. To make an
6083        asynchronous HTTP request, please define a `callback` function
6084        to be invoked when receiving the response.
6085        >>> def callback_function(response):
6086        >>>     pprint(response)
6087        >>>
6088        >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
6089
6090        :param callback function: The callback function
6091            for asynchronous request. (optional)
6092        :param str account_id: The external account number (int) or account ID GUID. (required)
6093        :param str brand_id: The ID of the brand. (required)
6094        :param str logo_type: The type of logo. Valid values are:  - `primary`  - `secondary`  - `email` (required)
6095        :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
6096        :return: None
6097                 If the method is called asynchronously,
6098                 returns the request thread.
6099        """
6100
6101        all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes']
6102        all_params.append('callback')
6103        all_params.append('_return_http_data_only')
6104        all_params.append('_preload_content')
6105        all_params.append('_request_timeout')
6106
6107        params = locals()
6108        for key, val in iteritems(params['kwargs']):
6109            if key not in all_params:
6110                raise TypeError(
6111                    "Got an unexpected keyword argument '%s'"
6112                    " to method update_brand_logo_by_type" % key
6113                )
6114            params[key] = val
6115        del params['kwargs']
6116        # verify the required parameter 'account_id' is set
6117        if ('account_id' not in params) or (params['account_id'] is None):
6118            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`")
6119        # verify the required parameter 'brand_id' is set
6120        if ('brand_id' not in params) or (params['brand_id'] is None):
6121            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`")
6122        # verify the required parameter 'logo_type' is set
6123        if ('logo_type' not in params) or (params['logo_type'] is None):
6124            raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`")
6125        # verify the required parameter 'logo_file_bytes' is set
6126        if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None):
6127            raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`")
6128
6129
6130        collection_formats = {}
6131
6132        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json')
6133        path_params = {}
6134        if 'account_id' in params:
6135            path_params['accountId'] = params['account_id']
6136        if 'brand_id' in params:
6137            path_params['brandId'] = params['brand_id']
6138        if 'logo_type' in params:
6139            path_params['logoType'] = params['logo_type']
6140
6141        query_params = {}
6142
6143        header_params = {}
6144
6145        form_params = []
6146        local_var_files = {}
6147
6148        body_params = None
6149        if 'logo_file_bytes' in params:
6150            body_params = params['logo_file_bytes']
6151        # HTTP header `Accept`
6152        header_params['Accept'] = self.api_client.\
6153            select_header_accept(['application/json'])
6154
6155        # HTTP header `Content-Type`
6156        header_params['Content-Type'] = self.api_client.\
6157            select_header_content_type(['image/png'])
6158
6159        # Authentication setting
6160        auth_settings = []
6161
6162        return self.api_client.call_api(resource_path, 'PUT',
6163                                        path_params,
6164                                        query_params,
6165                                        header_params,
6166                                        body=body_params,
6167                                        post_params=form_params,
6168                                        files=local_var_files,
6169                                        response_type=None,
6170                                        auth_settings=auth_settings,
6171                                        callback=params.get('callback'),
6172                                        _return_http_data_only=params.get('_return_http_data_only'),
6173                                        _preload_content=params.get('_preload_content', True),
6174                                        _request_timeout=params.get('_request_timeout'),
6175                                        collection_formats=collection_formats)

Put one branding logo. This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • str brand_id: The ID of the brand. (required)
  • str logo_type: The type of logo. Valid values are: - primary - secondary - email (required)
  • str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns

None If the method is called asynchronously, returns the request thread.

def update_brand_resources_by_content_type( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
6177    def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6178        """
6179        Uploads a branding resource file.
6180        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6181        This method makes a synchronous HTTP request by default. To make an
6182        asynchronous HTTP request, please define a `callback` function
6183        to be invoked when receiving the response.
6184        >>> def callback_function(response):
6185        >>>     pprint(response)
6186        >>>
6187        >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6188
6189        :param callback function: The callback function
6190            for asynchronous request. (optional)
6191        :param str account_id: The external account number (int) or account ID GUID. (required)
6192        :param str brand_id: The ID of the brand. (required)
6193        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6194        :param file file_xml: Brand resource XML file. (required)
6195        :return: BrandResources
6196                 If the method is called asynchronously,
6197                 returns the request thread.
6198        """
6199        kwargs['_return_http_data_only'] = True
6200        if kwargs.get('callback'):
6201            return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6202        else:
6203            (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs)
6204            return data

Uploads a branding resource file. This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • str brand_id: The ID of the brand. (required)
  • str resource_content_type: The type of brand resource file that you are updating. Valid values are: - sending - signing - email - signing_captive (required)
  • file file_xml: Brand resource XML file. (required)
Returns

BrandResources If the method is called asynchronously, returns the request thread.

def update_brand_resources_by_content_type_with_http_info( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
6206    def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs):
6207        """
6208        Uploads a branding resource file.
6209        This method updates a branding resource file.  You pass in the new version of the resource file in the `Content-Disposition` header. Example:  `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"`  **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**).  **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed.  When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
6210        This method makes a synchronous HTTP request by default. To make an
6211        asynchronous HTTP request, please define a `callback` function
6212        to be invoked when receiving the response.
6213        >>> def callback_function(response):
6214        >>>     pprint(response)
6215        >>>
6216        >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
6217
6218        :param callback function: The callback function
6219            for asynchronous request. (optional)
6220        :param str account_id: The external account number (int) or account ID GUID. (required)
6221        :param str brand_id: The ID of the brand. (required)
6222        :param str resource_content_type: The type of brand resource file that you are updating. Valid values are:  - `sending` - `signing` - `email` - `signing_captive` (required)
6223        :param file file_xml: Brand resource XML file. (required)
6224        :return: BrandResources
6225                 If the method is called asynchronously,
6226                 returns the request thread.
6227        """
6228
6229        all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml']
6230        all_params.append('callback')
6231        all_params.append('_return_http_data_only')
6232        all_params.append('_preload_content')
6233        all_params.append('_request_timeout')
6234
6235        params = locals()
6236        for key, val in iteritems(params['kwargs']):
6237            if key not in all_params:
6238                raise TypeError(
6239                    "Got an unexpected keyword argument '%s'"
6240                    " to method update_brand_resources_by_content_type" % key
6241                )
6242            params[key] = val
6243        del params['kwargs']
6244        # verify the required parameter 'account_id' is set
6245        if ('account_id' not in params) or (params['account_id'] is None):
6246            raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`")
6247        # verify the required parameter 'brand_id' is set
6248        if ('brand_id' not in params) or (params['brand_id'] is None):
6249            raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`")
6250        # verify the required parameter 'resource_content_type' is set
6251        if ('resource_content_type' not in params) or (params['resource_content_type'] is None):
6252            raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`")
6253        # verify the required parameter 'file_xml' is set
6254        if ('file_xml' not in params) or (params['file_xml'] is None):
6255            raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`")
6256
6257
6258        collection_formats = {}
6259
6260        resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json')
6261        path_params = {}
6262        if 'account_id' in params:
6263            path_params['accountId'] = params['account_id']
6264        if 'brand_id' in params:
6265            path_params['brandId'] = params['brand_id']
6266        if 'resource_content_type' in params:
6267            path_params['resourceContentType'] = params['resource_content_type']
6268
6269        query_params = {}
6270
6271        header_params = {}
6272
6273        form_params = []
6274        local_var_files = {}
6275        if 'file_xml' in params:
6276            local_var_files['file.xml'] = params['file_xml']
6277
6278        body_params = None
6279        # HTTP header `Accept`
6280        header_params['Accept'] = self.api_client.\
6281            select_header_accept(['application/json'])
6282
6283        # HTTP header `Content-Type`
6284        header_params['Content-Type'] = self.api_client.\
6285            select_header_content_type(['multipart/form-data'])
6286
6287        # Authentication setting
6288        auth_settings = []
6289
6290        return self.api_client.call_api(resource_path, 'PUT',
6291                                        path_params,
6292                                        query_params,
6293                                        header_params,
6294                                        body=body_params,
6295                                        post_params=form_params,
6296                                        files=local_var_files,
6297                                        response_type='BrandResources',
6298                                        auth_settings=auth_settings,
6299                                        callback=params.get('callback'),
6300                                        _return_http_data_only=params.get('_return_http_data_only'),
6301                                        _preload_content=params.get('_preload_content', True),
6302                                        _request_timeout=params.get('_request_timeout'),
6303                                        collection_formats=collection_formats)

Uploads a branding resource file. This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID GUID. (required)
  • str brand_id: The ID of the brand. (required)
  • str resource_content_type: The type of brand resource file that you are updating. Valid values are: - sending - signing - email - signing_captive (required)
  • file file_xml: Brand resource XML file. (required)
Returns

BrandResources If the method is called asynchronously, returns the request thread.

def update_consumer_disclosure(self, account_id, lang_code, **kwargs)
6305    def update_consumer_disclosure(self, account_id, lang_code, **kwargs):
6306        """
6307        Update Consumer Disclosure.
6308        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6309        This method makes a synchronous HTTP request by default. To make an
6310        asynchronous HTTP request, please define a `callback` function
6311        to be invoked when receiving the response.
6312        >>> def callback_function(response):
6313        >>>     pprint(response)
6314        >>>
6315        >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function)
6316
6317        :param callback function: The callback function
6318            for asynchronous request. (optional)
6319        :param str account_id: The external account number (int) or account ID Guid. (required)
6320        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6321        :param str include_metadata:
6322        :param ConsumerDisclosure consumer_disclosure:
6323        :return: ConsumerDisclosure
6324                 If the method is called asynchronously,
6325                 returns the request thread.
6326        """
6327        kwargs['_return_http_data_only'] = True
6328        if kwargs.get('callback'):
6329            return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6330        else:
6331            (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs)
6332            return data

Update Consumer Disclosure. Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
  • str include_metadata:
  • ConsumerDisclosure consumer_disclosure:
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
6334    def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs):
6335        """
6336        Update Consumer Disclosure.
6337        Account administrators can use this method to perform the following tasks:  - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure.   To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter.  **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version.   ## Updating the default disclosure  When you update the default disclosure, you can edit all properties except for the following ones:  - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only.  **Note:** The text of the default disclosure is always in English.  ## Switching to a custom disclosure  To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property.   You can also edit all of the other properties except for the following ones:  - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating.  **Important:**  When you switch from a default to a custom disclosure, note the following information:  - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  ## Updating a custom disclosure  When you update a custom disclosure, you can update all of the properties except for the following ones:  - `accountEsignId`: This property is read-only.  - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only.  **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.  
6338        This method makes a synchronous HTTP request by default. To make an
6339        asynchronous HTTP request, please define a `callback` function
6340        to be invoked when receiving the response.
6341        >>> def callback_function(response):
6342        >>>     pprint(response)
6343        >>>
6344        >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
6345
6346        :param callback function: The callback function
6347            for asynchronous request. (optional)
6348        :param str account_id: The external account number (int) or account ID Guid. (required)
6349        :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
6350        :param str include_metadata:
6351        :param ConsumerDisclosure consumer_disclosure:
6352        :return: ConsumerDisclosure
6353                 If the method is called asynchronously,
6354                 returns the request thread.
6355        """
6356
6357        all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure']
6358        all_params.append('callback')
6359        all_params.append('_return_http_data_only')
6360        all_params.append('_preload_content')
6361        all_params.append('_request_timeout')
6362
6363        params = locals()
6364        for key, val in iteritems(params['kwargs']):
6365            if key not in all_params:
6366                raise TypeError(
6367                    "Got an unexpected keyword argument '%s'"
6368                    " to method update_consumer_disclosure" % key
6369                )
6370            params[key] = val
6371        del params['kwargs']
6372        # verify the required parameter 'account_id' is set
6373        if ('account_id' not in params) or (params['account_id'] is None):
6374            raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`")
6375        # verify the required parameter 'lang_code' is set
6376        if ('lang_code' not in params) or (params['lang_code'] is None):
6377            raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`")
6378
6379
6380        collection_formats = {}
6381
6382        resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json')
6383        path_params = {}
6384        if 'account_id' in params:
6385            path_params['accountId'] = params['account_id']
6386        if 'lang_code' in params:
6387            path_params['langCode'] = params['lang_code']
6388
6389        query_params = {}
6390        if 'include_metadata' in params:
6391            query_params['include_metadata'] = params['include_metadata']
6392
6393        header_params = {}
6394
6395        form_params = []
6396        local_var_files = {}
6397
6398        body_params = None
6399        if 'consumer_disclosure' in params:
6400            body_params = params['consumer_disclosure']
6401        # HTTP header `Accept`
6402        header_params['Accept'] = self.api_client.\
6403            select_header_accept(['application/json'])
6404
6405        # Authentication setting
6406        auth_settings = []
6407
6408        return self.api_client.call_api(resource_path, 'PUT',
6409                                        path_params,
6410                                        query_params,
6411                                        header_params,
6412                                        body=body_params,
6413                                        post_params=form_params,
6414                                        files=local_var_files,
6415                                        response_type='ConsumerDisclosure',
6416                                        auth_settings=auth_settings,
6417                                        callback=params.get('callback'),
6418                                        _return_http_data_only=params.get('_return_http_data_only'),
6419                                        _preload_content=params.get('_preload_content', True),
6420                                        _request_timeout=params.get('_request_timeout'),
6421                                        collection_formats=collection_formats)

Update Consumer Disclosure. Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
  • str include_metadata:
  • ConsumerDisclosure consumer_disclosure:
Returns

ConsumerDisclosure If the method is called asynchronously, returns the request thread.

def update_custom_field(self, account_id, custom_field_id, **kwargs)
6423    def update_custom_field(self, account_id, custom_field_id, **kwargs):
6424        """
6425        Updates an existing account custom field.
6426        This method updates an existing account custom field.
6427        This method makes a synchronous HTTP request by default. To make an
6428        asynchronous HTTP request, please define a `callback` function
6429        to be invoked when receiving the response.
6430        >>> def callback_function(response):
6431        >>>     pprint(response)
6432        >>>
6433        >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function)
6434
6435        :param callback function: The callback function
6436            for asynchronous request. (optional)
6437        :param str account_id: The external account number (int) or account ID Guid. (required)
6438        :param str custom_field_id: (required)
6439        :param str apply_to_templates:
6440        :param CustomField custom_field:
6441        :return: CustomFields
6442                 If the method is called asynchronously,
6443                 returns the request thread.
6444        """
6445        kwargs['_return_http_data_only'] = True
6446        if kwargs.get('callback'):
6447            return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6448        else:
6449            (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs)
6450            return data

Updates an existing account custom field. This method updates an existing account custom field. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str custom_field_id: (required)
  • str apply_to_templates:
  • CustomField custom_field:
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
6452    def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs):
6453        """
6454        Updates an existing account custom field.
6455        This method updates an existing account custom field.
6456        This method makes a synchronous HTTP request by default. To make an
6457        asynchronous HTTP request, please define a `callback` function
6458        to be invoked when receiving the response.
6459        >>> def callback_function(response):
6460        >>>     pprint(response)
6461        >>>
6462        >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
6463
6464        :param callback function: The callback function
6465            for asynchronous request. (optional)
6466        :param str account_id: The external account number (int) or account ID Guid. (required)
6467        :param str custom_field_id: (required)
6468        :param str apply_to_templates:
6469        :param CustomField custom_field:
6470        :return: CustomFields
6471                 If the method is called asynchronously,
6472                 returns the request thread.
6473        """
6474
6475        all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field']
6476        all_params.append('callback')
6477        all_params.append('_return_http_data_only')
6478        all_params.append('_preload_content')
6479        all_params.append('_request_timeout')
6480
6481        params = locals()
6482        for key, val in iteritems(params['kwargs']):
6483            if key not in all_params:
6484                raise TypeError(
6485                    "Got an unexpected keyword argument '%s'"
6486                    " to method update_custom_field" % key
6487                )
6488            params[key] = val
6489        del params['kwargs']
6490        # verify the required parameter 'account_id' is set
6491        if ('account_id' not in params) or (params['account_id'] is None):
6492            raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`")
6493        # verify the required parameter 'custom_field_id' is set
6494        if ('custom_field_id' not in params) or (params['custom_field_id'] is None):
6495            raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`")
6496
6497
6498        collection_formats = {}
6499
6500        resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json')
6501        path_params = {}
6502        if 'account_id' in params:
6503            path_params['accountId'] = params['account_id']
6504        if 'custom_field_id' in params:
6505            path_params['customFieldId'] = params['custom_field_id']
6506
6507        query_params = {}
6508        if 'apply_to_templates' in params:
6509            query_params['apply_to_templates'] = params['apply_to_templates']
6510
6511        header_params = {}
6512
6513        form_params = []
6514        local_var_files = {}
6515
6516        body_params = None
6517        if 'custom_field' in params:
6518            body_params = params['custom_field']
6519        # HTTP header `Accept`
6520        header_params['Accept'] = self.api_client.\
6521            select_header_accept(['application/json'])
6522
6523        # Authentication setting
6524        auth_settings = []
6525
6526        return self.api_client.call_api(resource_path, 'PUT',
6527                                        path_params,
6528                                        query_params,
6529                                        header_params,
6530                                        body=body_params,
6531                                        post_params=form_params,
6532                                        files=local_var_files,
6533                                        response_type='CustomFields',
6534                                        auth_settings=auth_settings,
6535                                        callback=params.get('callback'),
6536                                        _return_http_data_only=params.get('_return_http_data_only'),
6537                                        _preload_content=params.get('_preload_content', True),
6538                                        _request_timeout=params.get('_request_timeout'),
6539                                        collection_formats=collection_formats)

Updates an existing account custom field. This method updates an existing account custom field. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str custom_field_id: (required)
  • str apply_to_templates:
  • CustomField custom_field:
Returns

CustomFields If the method is called asynchronously, returns the request thread.

def update_e_note_configuration(self, account_id, **kwargs)
6541    def update_e_note_configuration(self, account_id, **kwargs):
6542        """
6543        Updates configuration information for the eNote eOriginal integration.
6544        
6545        This method makes a synchronous HTTP request by default. To make an
6546        asynchronous HTTP request, please define a `callback` function
6547        to be invoked when receiving the response.
6548        >>> def callback_function(response):
6549        >>>     pprint(response)
6550        >>>
6551        >>> thread = api.update_e_note_configuration(account_id, callback=callback_function)
6552
6553        :param callback function: The callback function
6554            for asynchronous request. (optional)
6555        :param str account_id: The external account number (int) or account ID Guid. (required)
6556        :param ENoteConfiguration e_note_configuration:
6557        :return: ENoteConfiguration
6558                 If the method is called asynchronously,
6559                 returns the request thread.
6560        """
6561        kwargs['_return_http_data_only'] = True
6562        if kwargs.get('callback'):
6563            return self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6564        else:
6565            (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs)
6566            return data

Updates configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_e_note_configuration(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • ENoteConfiguration e_note_configuration:
Returns

ENoteConfiguration If the method is called asynchronously, returns the request thread.

def update_e_note_configuration_with_http_info(self, account_id, **kwargs)
6568    def update_e_note_configuration_with_http_info(self, account_id, **kwargs):
6569        """
6570        Updates configuration information for the eNote eOriginal integration.
6571        
6572        This method makes a synchronous HTTP request by default. To make an
6573        asynchronous HTTP request, please define a `callback` function
6574        to be invoked when receiving the response.
6575        >>> def callback_function(response):
6576        >>>     pprint(response)
6577        >>>
6578        >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function)
6579
6580        :param callback function: The callback function
6581            for asynchronous request. (optional)
6582        :param str account_id: The external account number (int) or account ID Guid. (required)
6583        :param ENoteConfiguration e_note_configuration:
6584        :return: ENoteConfiguration
6585                 If the method is called asynchronously,
6586                 returns the request thread.
6587        """
6588
6589        all_params = ['account_id', 'e_note_configuration']
6590        all_params.append('callback')
6591        all_params.append('_return_http_data_only')
6592        all_params.append('_preload_content')
6593        all_params.append('_request_timeout')
6594
6595        params = locals()
6596        for key, val in iteritems(params['kwargs']):
6597            if key not in all_params:
6598                raise TypeError(
6599                    "Got an unexpected keyword argument '%s'"
6600                    " to method update_e_note_configuration" % key
6601                )
6602            params[key] = val
6603        del params['kwargs']
6604        # verify the required parameter 'account_id' is set
6605        if ('account_id' not in params) or (params['account_id'] is None):
6606            raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`")
6607
6608
6609        collection_formats = {}
6610
6611        resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json')
6612        path_params = {}
6613        if 'account_id' in params:
6614            path_params['accountId'] = params['account_id']
6615
6616        query_params = {}
6617
6618        header_params = {}
6619
6620        form_params = []
6621        local_var_files = {}
6622
6623        body_params = None
6624        if 'e_note_configuration' in params:
6625            body_params = params['e_note_configuration']
6626        # HTTP header `Accept`
6627        header_params['Accept'] = self.api_client.\
6628            select_header_accept(['application/json'])
6629
6630        # Authentication setting
6631        auth_settings = []
6632
6633        return self.api_client.call_api(resource_path, 'PUT',
6634                                        path_params,
6635                                        query_params,
6636                                        header_params,
6637                                        body=body_params,
6638                                        post_params=form_params,
6639                                        files=local_var_files,
6640                                        response_type='ENoteConfiguration',
6641                                        auth_settings=auth_settings,
6642                                        callback=params.get('callback'),
6643                                        _return_http_data_only=params.get('_return_http_data_only'),
6644                                        _preload_content=params.get('_preload_content', True),
6645                                        _request_timeout=params.get('_request_timeout'),
6646                                        collection_formats=collection_formats)

Updates configuration information for the eNote eOriginal integration.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • ENoteConfiguration e_note_configuration:
Returns

ENoteConfiguration If the method is called asynchronously, returns the request thread.

def update_envelope_purge_configuration(self, account_id, **kwargs)
6648    def update_envelope_purge_configuration(self, account_id, **kwargs):
6649        """
6650        Updates envelope purge configuration.
6651        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6652        This method makes a synchronous HTTP request by default. To make an
6653        asynchronous HTTP request, please define a `callback` function
6654        to be invoked when receiving the response.
6655        >>> def callback_function(response):
6656        >>>     pprint(response)
6657        >>>
6658        >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function)
6659
6660        :param callback function: The callback function
6661            for asynchronous request. (optional)
6662        :param str account_id: The external account number (int) or account ID Guid. (required)
6663        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6664        :return: EnvelopePurgeConfiguration
6665                 If the method is called asynchronously,
6666                 returns the request thread.
6667        """
6668        kwargs['_return_http_data_only'] = True
6669        if kwargs.get('callback'):
6670            return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6671        else:
6672            (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs)
6673            return data

Updates envelope purge configuration. An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge Envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • EnvelopePurgeConfiguration envelope_purge_configuration:
Returns

EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.

def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
6675    def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs):
6676        """
6677        Updates envelope purge configuration.
6678        An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account.  **Note:** To use this method, you must be an account administrator.  For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes).
6679        This method makes a synchronous HTTP request by default. To make an
6680        asynchronous HTTP request, please define a `callback` function
6681        to be invoked when receiving the response.
6682        >>> def callback_function(response):
6683        >>>     pprint(response)
6684        >>>
6685        >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
6686
6687        :param callback function: The callback function
6688            for asynchronous request. (optional)
6689        :param str account_id: The external account number (int) or account ID Guid. (required)
6690        :param EnvelopePurgeConfiguration envelope_purge_configuration:
6691        :return: EnvelopePurgeConfiguration
6692                 If the method is called asynchronously,
6693                 returns the request thread.
6694        """
6695
6696        all_params = ['account_id', 'envelope_purge_configuration']
6697        all_params.append('callback')
6698        all_params.append('_return_http_data_only')
6699        all_params.append('_preload_content')
6700        all_params.append('_request_timeout')
6701
6702        params = locals()
6703        for key, val in iteritems(params['kwargs']):
6704            if key not in all_params:
6705                raise TypeError(
6706                    "Got an unexpected keyword argument '%s'"
6707                    " to method update_envelope_purge_configuration" % key
6708                )
6709            params[key] = val
6710        del params['kwargs']
6711        # verify the required parameter 'account_id' is set
6712        if ('account_id' not in params) or (params['account_id'] is None):
6713            raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`")
6714
6715
6716        collection_formats = {}
6717
6718        resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json')
6719        path_params = {}
6720        if 'account_id' in params:
6721            path_params['accountId'] = params['account_id']
6722
6723        query_params = {}
6724
6725        header_params = {}
6726
6727        form_params = []
6728        local_var_files = {}
6729
6730        body_params = None
6731        if 'envelope_purge_configuration' in params:
6732            body_params = params['envelope_purge_configuration']
6733        # HTTP header `Accept`
6734        header_params['Accept'] = self.api_client.\
6735            select_header_accept(['application/json'])
6736
6737        # Authentication setting
6738        auth_settings = []
6739
6740        return self.api_client.call_api(resource_path, 'PUT',
6741                                        path_params,
6742                                        query_params,
6743                                        header_params,
6744                                        body=body_params,
6745                                        post_params=form_params,
6746                                        files=local_var_files,
6747                                        response_type='EnvelopePurgeConfiguration',
6748                                        auth_settings=auth_settings,
6749                                        callback=params.get('callback'),
6750                                        _return_http_data_only=params.get('_return_http_data_only'),
6751                                        _preload_content=params.get('_preload_content', True),
6752                                        _request_timeout=params.get('_request_timeout'),
6753                                        collection_formats=collection_formats)

Updates envelope purge configuration. An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge Envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • EnvelopePurgeConfiguration envelope_purge_configuration:
Returns

EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.

def update_favorite_template(self, account_id, **kwargs)
6755    def update_favorite_template(self, account_id, **kwargs):
6756        """
6757        Favorites a template
6758        
6759        This method makes a synchronous HTTP request by default. To make an
6760        asynchronous HTTP request, please define a `callback` function
6761        to be invoked when receiving the response.
6762        >>> def callback_function(response):
6763        >>>     pprint(response)
6764        >>>
6765        >>> thread = api.update_favorite_template(account_id, callback=callback_function)
6766
6767        :param callback function: The callback function
6768            for asynchronous request. (optional)
6769        :param str account_id: The external account number (int) or account ID Guid. (required)
6770        :param FavoriteTemplatesInfo favorite_templates_info:
6771        :return: FavoriteTemplatesInfo
6772                 If the method is called asynchronously,
6773                 returns the request thread.
6774        """
6775        kwargs['_return_http_data_only'] = True
6776        if kwargs.get('callback'):
6777            return self.update_favorite_template_with_http_info(account_id, **kwargs)
6778        else:
6779            (data) = self.update_favorite_template_with_http_info(account_id, **kwargs)
6780            return data

Favorites a template

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_favorite_template(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • FavoriteTemplatesInfo favorite_templates_info:
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def update_favorite_template_with_http_info(self, account_id, **kwargs)
6782    def update_favorite_template_with_http_info(self, account_id, **kwargs):
6783        """
6784        Favorites a template
6785        
6786        This method makes a synchronous HTTP request by default. To make an
6787        asynchronous HTTP request, please define a `callback` function
6788        to be invoked when receiving the response.
6789        >>> def callback_function(response):
6790        >>>     pprint(response)
6791        >>>
6792        >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function)
6793
6794        :param callback function: The callback function
6795            for asynchronous request. (optional)
6796        :param str account_id: The external account number (int) or account ID Guid. (required)
6797        :param FavoriteTemplatesInfo favorite_templates_info:
6798        :return: FavoriteTemplatesInfo
6799                 If the method is called asynchronously,
6800                 returns the request thread.
6801        """
6802
6803        all_params = ['account_id', 'favorite_templates_info']
6804        all_params.append('callback')
6805        all_params.append('_return_http_data_only')
6806        all_params.append('_preload_content')
6807        all_params.append('_request_timeout')
6808
6809        params = locals()
6810        for key, val in iteritems(params['kwargs']):
6811            if key not in all_params:
6812                raise TypeError(
6813                    "Got an unexpected keyword argument '%s'"
6814                    " to method update_favorite_template" % key
6815                )
6816            params[key] = val
6817        del params['kwargs']
6818        # verify the required parameter 'account_id' is set
6819        if ('account_id' not in params) or (params['account_id'] is None):
6820            raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`")
6821
6822
6823        collection_formats = {}
6824
6825        resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json')
6826        path_params = {}
6827        if 'account_id' in params:
6828            path_params['accountId'] = params['account_id']
6829
6830        query_params = {}
6831
6832        header_params = {}
6833
6834        form_params = []
6835        local_var_files = {}
6836
6837        body_params = None
6838        if 'favorite_templates_info' in params:
6839            body_params = params['favorite_templates_info']
6840        # HTTP header `Accept`
6841        header_params['Accept'] = self.api_client.\
6842            select_header_accept(['application/json'])
6843
6844        # Authentication setting
6845        auth_settings = []
6846
6847        return self.api_client.call_api(resource_path, 'PUT',
6848                                        path_params,
6849                                        query_params,
6850                                        header_params,
6851                                        body=body_params,
6852                                        post_params=form_params,
6853                                        files=local_var_files,
6854                                        response_type='FavoriteTemplatesInfo',
6855                                        auth_settings=auth_settings,
6856                                        callback=params.get('callback'),
6857                                        _return_http_data_only=params.get('_return_http_data_only'),
6858                                        _preload_content=params.get('_preload_content', True),
6859                                        _request_timeout=params.get('_request_timeout'),
6860                                        collection_formats=collection_formats)

Favorites a template

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • FavoriteTemplatesInfo favorite_templates_info:
Returns

FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.

def update_notification_defaults(self, account_id, **kwargs)
6862    def update_notification_defaults(self, account_id, **kwargs):
6863        """
6864        Updates default user level settings for a specified account
6865        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6866        This method makes a synchronous HTTP request by default. To make an
6867        asynchronous HTTP request, please define a `callback` function
6868        to be invoked when receiving the response.
6869        >>> def callback_function(response):
6870        >>>     pprint(response)
6871        >>>
6872        >>> thread = api.update_notification_defaults(account_id, callback=callback_function)
6873
6874        :param callback function: The callback function
6875            for asynchronous request. (optional)
6876        :param str account_id: The external account number (int) or account ID Guid. (required)
6877        :param NotificationDefaults notification_defaults:
6878        :return: NotificationDefaults
6879                 If the method is called asynchronously,
6880                 returns the request thread.
6881        """
6882        kwargs['_return_http_data_only'] = True
6883        if kwargs.get('callback'):
6884            return self.update_notification_defaults_with_http_info(account_id, **kwargs)
6885        else:
6886            (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs)
6887            return data

Updates default user level settings for a specified account This method changes the default settings for the email notifications that signers and senders receive about envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_notification_defaults(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • NotificationDefaults notification_defaults:
Returns

NotificationDefaults If the method is called asynchronously, returns the request thread.

def update_notification_defaults_with_http_info(self, account_id, **kwargs)
6889    def update_notification_defaults_with_http_info(self, account_id, **kwargs):
6890        """
6891        Updates default user level settings for a specified account
6892        This method changes the default settings for the email notifications that signers and senders receive about envelopes.
6893        This method makes a synchronous HTTP request by default. To make an
6894        asynchronous HTTP request, please define a `callback` function
6895        to be invoked when receiving the response.
6896        >>> def callback_function(response):
6897        >>>     pprint(response)
6898        >>>
6899        >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function)
6900
6901        :param callback function: The callback function
6902            for asynchronous request. (optional)
6903        :param str account_id: The external account number (int) or account ID Guid. (required)
6904        :param NotificationDefaults notification_defaults:
6905        :return: NotificationDefaults
6906                 If the method is called asynchronously,
6907                 returns the request thread.
6908        """
6909
6910        all_params = ['account_id', 'notification_defaults']
6911        all_params.append('callback')
6912        all_params.append('_return_http_data_only')
6913        all_params.append('_preload_content')
6914        all_params.append('_request_timeout')
6915
6916        params = locals()
6917        for key, val in iteritems(params['kwargs']):
6918            if key not in all_params:
6919                raise TypeError(
6920                    "Got an unexpected keyword argument '%s'"
6921                    " to method update_notification_defaults" % key
6922                )
6923            params[key] = val
6924        del params['kwargs']
6925        # verify the required parameter 'account_id' is set
6926        if ('account_id' not in params) or (params['account_id'] is None):
6927            raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`")
6928
6929
6930        collection_formats = {}
6931
6932        resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json')
6933        path_params = {}
6934        if 'account_id' in params:
6935            path_params['accountId'] = params['account_id']
6936
6937        query_params = {}
6938
6939        header_params = {}
6940
6941        form_params = []
6942        local_var_files = {}
6943
6944        body_params = None
6945        if 'notification_defaults' in params:
6946            body_params = params['notification_defaults']
6947        # HTTP header `Accept`
6948        header_params['Accept'] = self.api_client.\
6949            select_header_accept(['application/json'])
6950
6951        # Authentication setting
6952        auth_settings = []
6953
6954        return self.api_client.call_api(resource_path, 'PUT',
6955                                        path_params,
6956                                        query_params,
6957                                        header_params,
6958                                        body=body_params,
6959                                        post_params=form_params,
6960                                        files=local_var_files,
6961                                        response_type='NotificationDefaults',
6962                                        auth_settings=auth_settings,
6963                                        callback=params.get('callback'),
6964                                        _return_http_data_only=params.get('_return_http_data_only'),
6965                                        _preload_content=params.get('_preload_content', True),
6966                                        _request_timeout=params.get('_request_timeout'),
6967                                        collection_formats=collection_formats)

Updates default user level settings for a specified account This method changes the default settings for the email notifications that signers and senders receive about envelopes. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • NotificationDefaults notification_defaults:
Returns

NotificationDefaults If the method is called asynchronously, returns the request thread.

def update_password_rules(self, account_id, **kwargs)
6969    def update_password_rules(self, account_id, **kwargs):
6970        """
6971        Update the password rules
6972        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
6973        This method makes a synchronous HTTP request by default. To make an
6974        asynchronous HTTP request, please define a `callback` function
6975        to be invoked when receiving the response.
6976        >>> def callback_function(response):
6977        >>>     pprint(response)
6978        >>>
6979        >>> thread = api.update_password_rules(account_id, callback=callback_function)
6980
6981        :param callback function: The callback function
6982            for asynchronous request. (optional)
6983        :param str account_id: The external account number (int) or account ID Guid. (required)
6984        :param AccountPasswordRules account_password_rules:
6985        :return: AccountPasswordRules
6986                 If the method is called asynchronously,
6987                 returns the request thread.
6988        """
6989        kwargs['_return_http_data_only'] = True
6990        if kwargs.get('callback'):
6991            return self.update_password_rules_with_http_info(account_id, **kwargs)
6992        else:
6993            (data) = self.update_password_rules_with_http_info(account_id, **kwargs)
6994            return data

Update the password rules This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_password_rules(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountPasswordRules account_password_rules:
Returns

AccountPasswordRules If the method is called asynchronously, returns the request thread.

def update_password_rules_with_http_info(self, account_id, **kwargs)
6996    def update_password_rules_with_http_info(self, account_id, **kwargs):
6997        """
6998        Update the password rules
6999        This method updates the password rules for an account.  **Note:** To update the password rules for an account, you must be an account administrator.
7000        This method makes a synchronous HTTP request by default. To make an
7001        asynchronous HTTP request, please define a `callback` function
7002        to be invoked when receiving the response.
7003        >>> def callback_function(response):
7004        >>>     pprint(response)
7005        >>>
7006        >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function)
7007
7008        :param callback function: The callback function
7009            for asynchronous request. (optional)
7010        :param str account_id: The external account number (int) or account ID Guid. (required)
7011        :param AccountPasswordRules account_password_rules:
7012        :return: AccountPasswordRules
7013                 If the method is called asynchronously,
7014                 returns the request thread.
7015        """
7016
7017        all_params = ['account_id', 'account_password_rules']
7018        all_params.append('callback')
7019        all_params.append('_return_http_data_only')
7020        all_params.append('_preload_content')
7021        all_params.append('_request_timeout')
7022
7023        params = locals()
7024        for key, val in iteritems(params['kwargs']):
7025            if key not in all_params:
7026                raise TypeError(
7027                    "Got an unexpected keyword argument '%s'"
7028                    " to method update_password_rules" % key
7029                )
7030            params[key] = val
7031        del params['kwargs']
7032        # verify the required parameter 'account_id' is set
7033        if ('account_id' not in params) or (params['account_id'] is None):
7034            raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`")
7035
7036
7037        collection_formats = {}
7038
7039        resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json')
7040        path_params = {}
7041        if 'account_id' in params:
7042            path_params['accountId'] = params['account_id']
7043
7044        query_params = {}
7045
7046        header_params = {}
7047
7048        form_params = []
7049        local_var_files = {}
7050
7051        body_params = None
7052        if 'account_password_rules' in params:
7053            body_params = params['account_password_rules']
7054        # HTTP header `Accept`
7055        header_params['Accept'] = self.api_client.\
7056            select_header_accept(['application/json'])
7057
7058        # Authentication setting
7059        auth_settings = []
7060
7061        return self.api_client.call_api(resource_path, 'PUT',
7062                                        path_params,
7063                                        query_params,
7064                                        header_params,
7065                                        body=body_params,
7066                                        post_params=form_params,
7067                                        files=local_var_files,
7068                                        response_type='AccountPasswordRules',
7069                                        auth_settings=auth_settings,
7070                                        callback=params.get('callback'),
7071                                        _return_http_data_only=params.get('_return_http_data_only'),
7072                                        _preload_content=params.get('_preload_content', True),
7073                                        _request_timeout=params.get('_request_timeout'),
7074                                        collection_formats=collection_formats)

Update the password rules This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountPasswordRules account_password_rules:
Returns

AccountPasswordRules If the method is called asynchronously, returns the request thread.

def update_permission_profile(self, account_id, permission_profile_id, **kwargs)
7076    def update_permission_profile(self, account_id, permission_profile_id, **kwargs):
7077        """
7078        Updates a permission profile within the specified account.
7079        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7080        This method makes a synchronous HTTP request by default. To make an
7081        asynchronous HTTP request, please define a `callback` function
7082        to be invoked when receiving the response.
7083        >>> def callback_function(response):
7084        >>>     pprint(response)
7085        >>>
7086        >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function)
7087
7088        :param callback function: The callback function
7089            for asynchronous request. (optional)
7090        :param str account_id: The external account number (int) or account ID Guid. (required)
7091        :param str permission_profile_id: (required)
7092        :param str include:
7093        :param PermissionProfile permission_profile:
7094        :return: PermissionProfile
7095                 If the method is called asynchronously,
7096                 returns the request thread.
7097        """
7098        kwargs['_return_http_data_only'] = True
7099        if kwargs.get('callback'):
7100            return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7101        else:
7102            (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs)
7103            return data

Updates a permission profile within the specified account. This method updates an account permission profile. ### Related topics - How to update individual permission settings This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str include:
  • PermissionProfile permission_profile:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
7105    def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs):
7106        """
7107        Updates a permission profile within the specified account.
7108        This method updates an account permission profile.  ### Related topics  - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 
7109        This method makes a synchronous HTTP request by default. To make an
7110        asynchronous HTTP request, please define a `callback` function
7111        to be invoked when receiving the response.
7112        >>> def callback_function(response):
7113        >>>     pprint(response)
7114        >>>
7115        >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
7116
7117        :param callback function: The callback function
7118            for asynchronous request. (optional)
7119        :param str account_id: The external account number (int) or account ID Guid. (required)
7120        :param str permission_profile_id: (required)
7121        :param str include:
7122        :param PermissionProfile permission_profile:
7123        :return: PermissionProfile
7124                 If the method is called asynchronously,
7125                 returns the request thread.
7126        """
7127
7128        all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile']
7129        all_params.append('callback')
7130        all_params.append('_return_http_data_only')
7131        all_params.append('_preload_content')
7132        all_params.append('_request_timeout')
7133
7134        params = locals()
7135        for key, val in iteritems(params['kwargs']):
7136            if key not in all_params:
7137                raise TypeError(
7138                    "Got an unexpected keyword argument '%s'"
7139                    " to method update_permission_profile" % key
7140                )
7141            params[key] = val
7142        del params['kwargs']
7143        # verify the required parameter 'account_id' is set
7144        if ('account_id' not in params) or (params['account_id'] is None):
7145            raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`")
7146        # verify the required parameter 'permission_profile_id' is set
7147        if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None):
7148            raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`")
7149
7150
7151        collection_formats = {}
7152
7153        resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json')
7154        path_params = {}
7155        if 'account_id' in params:
7156            path_params['accountId'] = params['account_id']
7157        if 'permission_profile_id' in params:
7158            path_params['permissionProfileId'] = params['permission_profile_id']
7159
7160        query_params = {}
7161        if 'include' in params:
7162            query_params['include'] = params['include']
7163
7164        header_params = {}
7165
7166        form_params = []
7167        local_var_files = {}
7168
7169        body_params = None
7170        if 'permission_profile' in params:
7171            body_params = params['permission_profile']
7172        # HTTP header `Accept`
7173        header_params['Accept'] = self.api_client.\
7174            select_header_accept(['application/json'])
7175
7176        # Authentication setting
7177        auth_settings = []
7178
7179        return self.api_client.call_api(resource_path, 'PUT',
7180                                        path_params,
7181                                        query_params,
7182                                        header_params,
7183                                        body=body_params,
7184                                        post_params=form_params,
7185                                        files=local_var_files,
7186                                        response_type='PermissionProfile',
7187                                        auth_settings=auth_settings,
7188                                        callback=params.get('callback'),
7189                                        _return_http_data_only=params.get('_return_http_data_only'),
7190                                        _preload_content=params.get('_preload_content', True),
7191                                        _request_timeout=params.get('_request_timeout'),
7192                                        collection_formats=collection_formats)

Updates a permission profile within the specified account. This method updates an account permission profile. ### Related topics - How to update individual permission settings This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str permission_profile_id: (required)
  • str include:
  • PermissionProfile permission_profile:
Returns

PermissionProfile If the method is called asynchronously, returns the request thread.

def update_settings(self, account_id, **kwargs)
7194    def update_settings(self, account_id, **kwargs):
7195        """
7196        Updates the account settings for an account.
7197        Updates the account settings for the specified account.
7198        This method makes a synchronous HTTP request by default. To make an
7199        asynchronous HTTP request, please define a `callback` function
7200        to be invoked when receiving the response.
7201        >>> def callback_function(response):
7202        >>>     pprint(response)
7203        >>>
7204        >>> thread = api.update_settings(account_id, callback=callback_function)
7205
7206        :param callback function: The callback function
7207            for asynchronous request. (optional)
7208        :param str account_id: The external account number (int) or account ID Guid. (required)
7209        :param AccountSettingsInformation account_settings_information:
7210        :return: None
7211                 If the method is called asynchronously,
7212                 returns the request thread.
7213        """
7214        kwargs['_return_http_data_only'] = True
7215        if kwargs.get('callback'):
7216            return self.update_settings_with_http_info(account_id, **kwargs)
7217        else:
7218            (data) = self.update_settings_with_http_info(account_id, **kwargs)
7219            return data

Updates the account settings for an account. Updates the account settings for the specified account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_settings(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountSettingsInformation account_settings_information:
Returns

None If the method is called asynchronously, returns the request thread.

def update_settings_with_http_info(self, account_id, **kwargs)
7221    def update_settings_with_http_info(self, account_id, **kwargs):
7222        """
7223        Updates the account settings for an account.
7224        Updates the account settings for the specified account.
7225        This method makes a synchronous HTTP request by default. To make an
7226        asynchronous HTTP request, please define a `callback` function
7227        to be invoked when receiving the response.
7228        >>> def callback_function(response):
7229        >>>     pprint(response)
7230        >>>
7231        >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function)
7232
7233        :param callback function: The callback function
7234            for asynchronous request. (optional)
7235        :param str account_id: The external account number (int) or account ID Guid. (required)
7236        :param AccountSettingsInformation account_settings_information:
7237        :return: None
7238                 If the method is called asynchronously,
7239                 returns the request thread.
7240        """
7241
7242        all_params = ['account_id', 'account_settings_information']
7243        all_params.append('callback')
7244        all_params.append('_return_http_data_only')
7245        all_params.append('_preload_content')
7246        all_params.append('_request_timeout')
7247
7248        params = locals()
7249        for key, val in iteritems(params['kwargs']):
7250            if key not in all_params:
7251                raise TypeError(
7252                    "Got an unexpected keyword argument '%s'"
7253                    " to method update_settings" % key
7254                )
7255            params[key] = val
7256        del params['kwargs']
7257        # verify the required parameter 'account_id' is set
7258        if ('account_id' not in params) or (params['account_id'] is None):
7259            raise ValueError("Missing the required parameter `account_id` when calling `update_settings`")
7260
7261
7262        collection_formats = {}
7263
7264        resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json')
7265        path_params = {}
7266        if 'account_id' in params:
7267            path_params['accountId'] = params['account_id']
7268
7269        query_params = {}
7270
7271        header_params = {}
7272
7273        form_params = []
7274        local_var_files = {}
7275
7276        body_params = None
7277        if 'account_settings_information' in params:
7278            body_params = params['account_settings_information']
7279        # HTTP header `Accept`
7280        header_params['Accept'] = self.api_client.\
7281            select_header_accept(['application/json'])
7282
7283        # Authentication setting
7284        auth_settings = []
7285
7286        return self.api_client.call_api(resource_path, 'PUT',
7287                                        path_params,
7288                                        query_params,
7289                                        header_params,
7290                                        body=body_params,
7291                                        post_params=form_params,
7292                                        files=local_var_files,
7293                                        response_type=None,
7294                                        auth_settings=auth_settings,
7295                                        callback=params.get('callback'),
7296                                        _return_http_data_only=params.get('_return_http_data_only'),
7297                                        _preload_content=params.get('_preload_content', True),
7298                                        _request_timeout=params.get('_request_timeout'),
7299                                        collection_formats=collection_formats)

Updates the account settings for an account. Updates the account settings for the specified account. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_settings_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • AccountSettingsInformation account_settings_information:
Returns

None If the method is called asynchronously, returns the request thread.

def update_shared_access(self, account_id, **kwargs)
7301    def update_shared_access(self, account_id, **kwargs):
7302        """
7303        Reserved: Sets the shared access information for users.
7304        Reserved: Sets the shared access information for one or more users.
7305        This method makes a synchronous HTTP request by default. To make an
7306        asynchronous HTTP request, please define a `callback` function
7307        to be invoked when receiving the response.
7308        >>> def callback_function(response):
7309        >>>     pprint(response)
7310        >>>
7311        >>> thread = api.update_shared_access(account_id, callback=callback_function)
7312
7313        :param callback function: The callback function
7314            for asynchronous request. (optional)
7315        :param str account_id: The external account number (int) or account ID Guid. (required)
7316        :param str item_type:
7317        :param str preserve_existing_shared_access:
7318        :param str user_ids:
7319        :param AccountSharedAccess account_shared_access:
7320        :return: AccountSharedAccess
7321                 If the method is called asynchronously,
7322                 returns the request thread.
7323        """
7324        kwargs['_return_http_data_only'] = True
7325        if kwargs.get('callback'):
7326            return self.update_shared_access_with_http_info(account_id, **kwargs)
7327        else:
7328            (data) = self.update_shared_access_with_http_info(account_id, **kwargs)
7329            return data

Reserved: Sets the shared access information for users. Reserved: Sets the shared access information for one or more users. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_shared_access(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str item_type:
  • str preserve_existing_shared_access:
  • str user_ids:
  • AccountSharedAccess account_shared_access:
Returns

AccountSharedAccess If the method is called asynchronously, returns the request thread.

def update_shared_access_with_http_info(self, account_id, **kwargs)
7331    def update_shared_access_with_http_info(self, account_id, **kwargs):
7332        """
7333        Reserved: Sets the shared access information for users.
7334        Reserved: Sets the shared access information for one or more users.
7335        This method makes a synchronous HTTP request by default. To make an
7336        asynchronous HTTP request, please define a `callback` function
7337        to be invoked when receiving the response.
7338        >>> def callback_function(response):
7339        >>>     pprint(response)
7340        >>>
7341        >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function)
7342
7343        :param callback function: The callback function
7344            for asynchronous request. (optional)
7345        :param str account_id: The external account number (int) or account ID Guid. (required)
7346        :param str item_type:
7347        :param str preserve_existing_shared_access:
7348        :param str user_ids:
7349        :param AccountSharedAccess account_shared_access:
7350        :return: AccountSharedAccess
7351                 If the method is called asynchronously,
7352                 returns the request thread.
7353        """
7354
7355        all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access']
7356        all_params.append('callback')
7357        all_params.append('_return_http_data_only')
7358        all_params.append('_preload_content')
7359        all_params.append('_request_timeout')
7360
7361        params = locals()
7362        for key, val in iteritems(params['kwargs']):
7363            if key not in all_params:
7364                raise TypeError(
7365                    "Got an unexpected keyword argument '%s'"
7366                    " to method update_shared_access" % key
7367                )
7368            params[key] = val
7369        del params['kwargs']
7370        # verify the required parameter 'account_id' is set
7371        if ('account_id' not in params) or (params['account_id'] is None):
7372            raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`")
7373
7374
7375        collection_formats = {}
7376
7377        resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json')
7378        path_params = {}
7379        if 'account_id' in params:
7380            path_params['accountId'] = params['account_id']
7381
7382        query_params = {}
7383        if 'item_type' in params:
7384            query_params['item_type'] = params['item_type']
7385        if 'preserve_existing_shared_access' in params:
7386            query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access']
7387        if 'user_ids' in params:
7388            query_params['user_ids'] = params['user_ids']
7389
7390        header_params = {}
7391
7392        form_params = []
7393        local_var_files = {}
7394
7395        body_params = None
7396        if 'account_shared_access' in params:
7397            body_params = params['account_shared_access']
7398        # HTTP header `Accept`
7399        header_params['Accept'] = self.api_client.\
7400            select_header_accept(['application/json'])
7401
7402        # Authentication setting
7403        auth_settings = []
7404
7405        return self.api_client.call_api(resource_path, 'PUT',
7406                                        path_params,
7407                                        query_params,
7408                                        header_params,
7409                                        body=body_params,
7410                                        post_params=form_params,
7411                                        files=local_var_files,
7412                                        response_type='AccountSharedAccess',
7413                                        auth_settings=auth_settings,
7414                                        callback=params.get('callback'),
7415                                        _return_http_data_only=params.get('_return_http_data_only'),
7416                                        _preload_content=params.get('_preload_content', True),
7417                                        _request_timeout=params.get('_request_timeout'),
7418                                        collection_formats=collection_formats)

Reserved: Sets the shared access information for users. Reserved: Sets the shared access information for one or more users. This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • str item_type:
  • str preserve_existing_shared_access:
  • str user_ids:
  • AccountSharedAccess account_shared_access:
Returns

AccountSharedAccess If the method is called asynchronously, returns the request thread.

def update_watermark(self, account_id, **kwargs)
7420    def update_watermark(self, account_id, **kwargs):
7421        """
7422        Update watermark information.
7423        
7424        This method makes a synchronous HTTP request by default. To make an
7425        asynchronous HTTP request, please define a `callback` function
7426        to be invoked when receiving the response.
7427        >>> def callback_function(response):
7428        >>>     pprint(response)
7429        >>>
7430        >>> thread = api.update_watermark(account_id, callback=callback_function)
7431
7432        :param callback function: The callback function
7433            for asynchronous request. (optional)
7434        :param str account_id: The external account number (int) or account ID Guid. (required)
7435        :param Watermark watermark:
7436        :return: Watermark
7437                 If the method is called asynchronously,
7438                 returns the request thread.
7439        """
7440        kwargs['_return_http_data_only'] = True
7441        if kwargs.get('callback'):
7442            return self.update_watermark_with_http_info(account_id, **kwargs)
7443        else:
7444            (data) = self.update_watermark_with_http_info(account_id, **kwargs)
7445            return data

Update watermark information.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_watermark(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • Watermark watermark:
Returns

Watermark If the method is called asynchronously, returns the request thread.

def update_watermark_with_http_info(self, account_id, **kwargs)
7447    def update_watermark_with_http_info(self, account_id, **kwargs):
7448        """
7449        Update watermark information.
7450        
7451        This method makes a synchronous HTTP request by default. To make an
7452        asynchronous HTTP request, please define a `callback` function
7453        to be invoked when receiving the response.
7454        >>> def callback_function(response):
7455        >>>     pprint(response)
7456        >>>
7457        >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function)
7458
7459        :param callback function: The callback function
7460            for asynchronous request. (optional)
7461        :param str account_id: The external account number (int) or account ID Guid. (required)
7462        :param Watermark watermark:
7463        :return: Watermark
7464                 If the method is called asynchronously,
7465                 returns the request thread.
7466        """
7467
7468        all_params = ['account_id', 'watermark']
7469        all_params.append('callback')
7470        all_params.append('_return_http_data_only')
7471        all_params.append('_preload_content')
7472        all_params.append('_request_timeout')
7473
7474        params = locals()
7475        for key, val in iteritems(params['kwargs']):
7476            if key not in all_params:
7477                raise TypeError(
7478                    "Got an unexpected keyword argument '%s'"
7479                    " to method update_watermark" % key
7480                )
7481            params[key] = val
7482        del params['kwargs']
7483        # verify the required parameter 'account_id' is set
7484        if ('account_id' not in params) or (params['account_id'] is None):
7485            raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`")
7486
7487
7488        collection_formats = {}
7489
7490        resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json')
7491        path_params = {}
7492        if 'account_id' in params:
7493            path_params['accountId'] = params['account_id']
7494
7495        query_params = {}
7496
7497        header_params = {}
7498
7499        form_params = []
7500        local_var_files = {}
7501
7502        body_params = None
7503        if 'watermark' in params:
7504            body_params = params['watermark']
7505        # HTTP header `Accept`
7506        header_params['Accept'] = self.api_client.\
7507            select_header_accept(['application/json'])
7508
7509        # Authentication setting
7510        auth_settings = []
7511
7512        return self.api_client.call_api(resource_path, 'PUT',
7513                                        path_params,
7514                                        query_params,
7515                                        header_params,
7516                                        body=body_params,
7517                                        post_params=form_params,
7518                                        files=local_var_files,
7519                                        response_type='Watermark',
7520                                        auth_settings=auth_settings,
7521                                        callback=params.get('callback'),
7522                                        _return_http_data_only=params.get('_return_http_data_only'),
7523                                        _preload_content=params.get('_preload_content', True),
7524                                        _request_timeout=params.get('_request_timeout'),
7525                                        collection_formats=collection_formats)

Update watermark information.

This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please define a callback function to be invoked when receiving the response.

>>> def callback_function(response):
>>>     pprint(response)
>>>
>>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function)
Parameters
  • callback function: The callback function for asynchronous request. (optional)
  • str account_id: The external account number (int) or account ID Guid. (required)
  • Watermark watermark:
Returns

Watermark If the method is called asynchronously, returns the request thread.